How I automated hyper-local lead routing with Nextdoor Scraper and Slack

Picture this. A sales rep or local contractor sitting in their truck on a Tuesday morning, burning fuel driving 45 minutes across town to quote a home repair, only to discover the prospect is a renter who cannot authorize work. Meanwhile, three streets over, in a hidden, high-density homeowner neighborhood, local residents are actively posting on Nextdoor to ask for contractor recommendations.

Collecting hyper-local data into a weekly CSV export is like brewing a fresh pot of coffee and leaving it on the counter for two days before serving it to your sales team. By the time an analyst manually exports the dataset, filters target zip codes, and emails the report to reps, those golden neighborhood opportunities are cold and competitors have already booked the jobs.

However, extracting this hyper-local data from public sources has historically presented a severe operational challenge. Nextdoor is a rich ecosystem for local community context, but manually researching across hundreds of city pages is painfully slow. Worse still, traditional web scraping workflows often deposit extracted data into static CSV files or database tables that sit idle until someone manually reviews them days later. In high-intent lead generation, every hour of delay degrades lead momentum and lowers conversion rates.

To solve this problem, I built two complementary lead routing workflows around Nextdoor Scraper on the Apify platform. The first is a no-code Slack notification wired directly inside Apify Console. The second is an AI agent workflow that connects Nextdoor Scraper to Claude or Cursor via the Apify MCP server, letting an AI agent run the scraper, filter results, and push alerts to Slack through a single conversational prompt.

In this article, I will walk you through the extraction setup, the qualification filter logic, both Slack routing approaches, and exactly what each option looks like in practice.

1. The gap between data collection and sales action

For home service providers, such as plumbers, roofers, HVAC technicians, landscapers, and solar installers, speed and geographic precision are everything. Identifying an ideal target neighborhood is only half the battle. If your sales team receives demographic reports 48 hours after a data crawl finishes, the opportunity to run timely local direct mail campaigns, localized digital ad pushes, or door-to-door outreach in high-demand pockets has already started to slip.

+-------------------+      +--------------------+      +----------------------+
|  Public Nextdoor  | ---> |  Nextdoor Scraper  | ---> |  Data Dump (CSV/DB)  |
|    City Pages     |      |  (Manual Crawl)    |      |  (Sits Idle Days)    |
+-------------------+      +--------------------+      +----------------------+
                                                                  |
                                                                  v
                                                       [ Delayed Sales Action ]

The primary friction point in modern web scraping is not extracting the data - it is the latency between data acquisition and business action. Traditional workflows decouple extraction from execution:

1. A crawler runs and outputs thousands of raw records into key-value stores or CSV files.
2. An analyst exports the CSV and manually applies spreadsheet filters to isolate target zip codes.
3. The analyst formats a report and emails it to the sales lead.
4. The sales lead assigns territories to reps who finally begin outreach.

This multi-step, manual chain creates massive operational friction. By the time reps receive the target list, days have elapsed.

To eliminate this gap, I built two notification paths that both start from the same Nextdoor Scraper run, and both deliver results to Slack, but in different ways depending on your team's setup.

+-------------------+      +--------------------+      +---------------------+
|  Public Nextdoor  | ---> |  Nextdoor Scraper  | ---> |  Apify Dataset      |
|    City Pages     |      |  (Apify Platform)  |      |  (Structured JSON)  |
+-------------------+      +--------------------+      +---------------------+
                                                                  |
                          +--------------------------+------------+
                          |                          |
                          v                          v
             [ Path A: No-code ]        [ Path B: MCP server ]
             Slack notification         AI agent (Claude/Cursor)
             via Actor integration      calls Nextdoor Scraper,
             inside Apify Console       filters leads, posts to Slack

---

2. The pipeline architecture

The automated lead routing system operates across two stages: extraction and post-run notification.

sequenceDiagram
    autonumber
    participant ND as Public Nextdoor Pages
    participant NS as Nextdoor Scraper (Apify Platform)
    participant DS as Apify Dataset
    participant SL as Slack (#local-leads)
    participant AI as AI Agent (Claude / Cursor)

    ND->>NS: Fetch public city & neighborhood page HTML
    NS->>DS: Store structured place data (centroid, income, homeowners)
    Note over DS: Run completes. Dataset is ready.

    alt Path A: No-code Slack notification
        DS->>SL: Actor integration fires on run finish
        SL-->>DS: Notification delivered
    else Path B: MCP server + AI agent
        AI->>NS: call-actor via Apify MCP server (mcp.apify.com)
        NS->>DS: Actor runs and stores results
        DS->>AI: AI agent reads dataset items
        AI->>AI: Filter by homeowners >= 50%, income >= $40k
        AI->>SL: Post formatted alert via Slack bot or Slack MCP tool
    end

Stage 1: Extraction

The workflow begins by launching Nextdoor Scraper on the Apify platform. The Actor targets public Nextdoor city and neighborhood pages, bypassing the need for complex browser automation setups or raw HTML parsing scripts. It parses visible structured data and metadata, transforming disorganized web content into clean JSON records that include geographic coordinates, demographic metrics, resident counts, and references to community activity.

Stage 2: Notification routing

Once the Actor run finishes and the dataset is populated, there are two ways to get that data into Slack. The first requires no code at all. The second turns the entire pipeline into something an AI agent like Claude or Cursor can trigger, filter, and broadcast with a single prompt.

---

3. Step 1: Extracting targeted neighborhood demographics

To get started, we configure Nextdoor Scraper to target public city pages. Nextdoor public city pages display valuable summary metrics without requiring user logins or private authentication.

Input configuration

In Apify Console, open the Input tab for Nextdoor Scraper and supply your target city URLs along with crawl limits. Here is the JSON input configuration used for this pipeline:

{
  "startUrls": [
    { "url": "https://nextdoor.com/city/north-miami--fl/" },
    { "url": "https://nextdoor.com/city/bellaire--oh/" },
    { "url": "https://nextdoor.com/city/bellbrook--oh/" },
    { "url": "https://nextdoor.com/city/belle-center--oh/" }
  ],
  "downloadStartUrlsToHtmlSources": false,
  "maxRequestsPerCrawl": 20,
  "maxConcurrency": 2,
  "maxItemsPerSection": 25,
  "followNeighborhoodPages": true,
  "followBusinessDirectoryPages": false,
  "followAdditionalResourcePages": false,
  "saveHtmlSnapshots": false
}

Key demographic fields extracted

When Nextdoor Scraper processes a city page, it returns normalized fields ready for immediate analysis:

Field	Type	Description	Sample Value
cityName	String	Name of the target city or municipality	"North Miami"
state	String	Two-letter state abbreviation	"FL"
centroid	Object	Geographic center latitude and longitude	{"latitude": 40.016, "longitude": -80.747}
residentsCount	Integer	Total estimated residents in the area	59854
averageAge	Integer	Average resident age	35
averageIncome	String	Public average household income indicator	"$41k"
percentageHomeowners	String	Share of residents who own their homes	"56%"
affordabilityScore	Integer	Calculated local affordability index	99
friendlinessScore	Integer	Community friendliness score	86
faqs	Array	Structured FAQ question and answer pairs	[{"question": "...", "answer": "..."}]
neighborhoods	Array	Discovered public neighborhood links	[{"title": "128th St", "url": "..."}]

Sample output JSON

Here is a snippet of the structured dataset item generated by Nextdoor Scraper:

{
  "url": "https://nextdoor.com/city/north-miami--fl/",
  "finalUrl": "https://nextdoor.com/city/north-miami--fl/",
  "pageType": "city",
  "title": "North Miami, Florida | Nextdoor",
  "description": "Public city summary extracted from Nextdoor.",
  "cityName": "North Miami",
  "state": "FL",
  "centroid": {
    "latitude": 25.8901,
    "longitude": -80.1867
  },
  "residentsCount": 59854,
  "averageAge": 38,
  "averageIncome": "$48k",
  "percentageHomeowners": "54%",
  "affordabilityScore": 82,
  "friendlinessScore": 88,
  "neighborhoodCount": 26,
  "businessDirectoryCount": 54,
  "faqCount": 7,
  "accessStatus": "public"
}

Cost efficiency with Pay-Per-Event pricing

One major advantage of using Nextdoor Scraper on the Apify platform is its pricing structure. Nextdoor Scraper operates on a Pay-Per-Event (PPE) model.

Unlike traditional compute-hour billing where you pay for raw server uptime regardless of success, PPE charging means you are billed strictly for successfully extracted place records. If a network fluctuation or access block occurs on a page, you are not billed for that failed attempt. This ensures predictable margins when executing large-scale, automated lead discovery campaigns across thousands of zip codes.

4. Step 2: Filtering for contractor accountability and intent

To understand how conditional filtering works in practice, let us examine a real-world implementation executed during a regional contractor accountability platform pilot with Lake Rock Ventures.

The Lake Rock Ventures pilot scenario

Lake Rock Ventures, a venture growth studio, was launching a pilot platform designed to connect vetted local roofing and HVAC contractors with high-intent homeowners. The platform needed to identify suburban communities with high enough homeownership rates to justify targeted direct-response marketing. Sending contractor representatives into renter-heavy neighborhoods resulted in wasted labor costs and low conversion rates.

To solve this, we defined strict qualification parameters for acceptable lead routing:

1. Homeowner ratio (percentageHomeowners): Minimum of 50%. Homeowners make long-term property decisions; renters rarely purchase roof replacements or HVAC upgrades.
2. Community scale (residentsCount): Minimum of 1,000 residents to guarantee adequate market volume.
3. Income indicator (averageIncome): Must meet or exceed $40k to ensure purchasing power for home improvement projects.

Writing the mid-run evaluation logic

We implemented a custom evaluation function in JavaScript that processes each dataset record emitted by Nextdoor Scraper. The script parses formatted strings (such as "56%" or "$48k") into clean numerical values and tests them against our threshold rules.

/**
 * Evaluates whether an extracted Nextdoor dataset item qualifies as a high-intent local lead.
 * @param {Object} item - Structured record from Nextdoor Scraper.
 * @returns {Object} Qualification result containing boolean status and parsed metrics.
 */
function evaluateLeadQualification(item) {
    // Extract numerical value from percentage string e.g., "56%" -> 56
    const homeownerRate = item.percentageHomeowners 
        ? parseFloat(item.percentageHomeowners.replace('%', '')) 
        : 0;

    // Extract numerical value from income string e.g., "$48k" -> 48000
    let incomeValue = 0;
    if (item.averageIncome) {
        const rawIncome = item.averageIncome.replace('$', '').toLowerCase();
        if (rawIncome.includes('k')) {
            incomeValue = parseFloat(rawIncome.replace('k', '')) * 1000;
        } else {
            incomeValue = parseFloat(rawIncome);
        }
    }

    const residentCount = item.residentsCount || 0;

    // Qualification thresholds
    const MIN_HOMEOWNER_PERCENT = 50;
    const MIN_INCOME = 40000;
    const MIN_RESIDENTS = 1000;

    const isQualified = 
        homeownerRate >= MIN_HOMEOWNER_PERCENT &&
        incomeValue >= MIN_INCOME &&
        residentCount >= MIN_RESIDENTS;

    return {
        isQualified,
        metrics: {
            homeownerRate,
            incomeValue,
            residentCount,
            affordabilityScore: item.affordabilityScore || 'N/A',
            friendlinessScore: item.friendlinessScore || 'N/A'
        }
    };
}

By embedding this evaluation logic directly into our execution pipeline, every crawled page is screened within milliseconds of extraction. If isQualified evaluates to true, the pipeline proceeds to dispatch a real-time Slack notification.

5. Step 3 (Path A): Sending a Slack notification with no code

Apify Console includes a built-in Slack notification integration for every Actor. It requires no custom code, no webhook endpoint, and no token management. You set it up once directly on the Nextdoor Scraper Actor page and it fires automatically after every run.

Setting up the Slack notification in Apify Console

1. Open Nextdoor Scraper in Apify Console and click the Integrations tab in the Actor's top navigation.
2. In the Search integrations bar, type slack. You will see a Send notification via Slack option listed under Generic integrations.
3. Click Send notification via Slack. A panel appears with a Connect workspace button.
4. Click Connect workspace and authorize the Apify app to access your Slack workspace. Select the target channel, such as #local-leads.
5. Configure when the notification fires. The most useful trigger is Run succeeded, which posts a Slack message automatically each time a Nextdoor Scraper run completes successfully.
6. Save the integration. From this point forward, every completed run posts a notification to your chosen Slack channel without any additional code.

The notification includes the run status, a direct link to the dataset in Apify Console, and the Actor name. Your sales team gets an immediate signal that fresh neighborhood data is ready to review, without having to log in and check manually.

+--------------------+      +---------------------+      +------------------------------+
| Nextdoor Scraper   | ---> | Run succeeds        | ---> | Slack: #local-leads          |
| (Apify Console)    |      | (Apify Platform)    |      | "Your run finished. View      |
|                    |      |                     |      |  results in Apify Console."  |
+--------------------+      +---------------------+      +------------------------------+

This is the fastest path to getting Slack alerts from Nextdoor Scraper. It takes under two minutes to configure and works on every run automatically, including scheduled runs and saved tasks.

---

6. Step 4 (Path B): Using the Apify MCP server with an AI agent

Path A sends a basic completion notification. Path B goes further: it lets an AI agent such as Claude or Cursor actually run Nextdoor Scraper, read and filter the extracted dataset, and post a formatted, actionable Slack alert with specific neighborhood metrics - all from a single conversational prompt.

This is possible because Apify hosts a remote Model Context Protocol (MCP) server at https://mcp.apify.com. Once you connect an MCP client to that server, your AI agent gains access to tools such as call-actor, search-actors, and fetch-actor-details. It can run Nextdoor Scraper on demand and process the results directly inside the chat context.

What is the Apify MCP server?

The Apify MCP server exposes Apify Actors as callable tools to external AI clients. It is a programmatic interface that works with any MCP-compatible client, including Claude for Desktop, Cursor, VS Code with MCP support, and others.

This is distinct from MCP connectors, which work in the opposite direction (an Actor calling an external service). The Apify MCP server makes Actors available as tools your AI agent can invoke from outside Apify entirely.

Connecting the Apify MCP server to your AI client

You authorize once via OAuth browser flow. After that, your AI client can call Nextdoor Scraper directly.

Cursor - create or update .cursor/mcp.json in your project:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=actors,docs,eunit/nextdoor-scraper"
    }
  }
}

VS Code - add to .vscode/mcp.json or run MCP: Add Server from the Command Palette:

{
  "servers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=actors,docs,eunit/nextdoor-scraper"
    }
  }
}

Claude for Desktop - edit claude_desktop_config.json:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=actors,docs,eunit/nextdoor-scraper"
      ]
    }
  }
}

The ?tools=actors,docs,eunit/nextdoor-scraper query parameter scopes the tools list to the Nextdoor Scraper Actor specifically, alongside general Actor search and documentation tools. On first connection, a browser OAuth flow opens so you sign in to your Apify account and approve access. No API token is pasted into the chat.

Running the pipeline from a prompt

Once configured, the entire extraction and filtering workflow becomes a single AI prompt. Here is an example of what you would type in Claude or Cursor:

Use Apify to run the Nextdoor Scraper on these four city pages: north-miami--fl, bellaire--oh, bellbrook--oh, and belle-center--oh. Once finished, read the dataset results. Filter for any city where percentageHomeowners is 50% or above and averageIncome is $40k or above. For each qualifying city, format a Slack message with the city name, homeowner share, average income, resident count, and affordability score, then post it to #local-leads.

The AI agent handles the full sequence:

1. Calls call-actor with the Nextdoor Scraper Actor ID and input configuration.
2. Waits for the run to complete and fetches the dataset items.
3. Applies your qualification filter logic across every result.
4. Formats a structured message for each qualifying neighborhood.
5. Posts the alert to Slack using either a connected Slack MCP tool or a Slack bot token you provide in the chat context.

+------------------+      +----------------------+      +------------------+      +------------------+
| AI Agent         | ---> | Apify MCP server     | ---> | Nextdoor Scraper | ---> | Apify Dataset    |
| (Claude/Cursor)  |      | mcp.apify.com        |      | (Actor run)      |      | (JSON results)   |
| call-actor tool  |      | (OAuth, no token     |      |                  |      |                  |
|                  |      |  in chat)            |      |                  |      |                  |
+------------------+      +----------------------+      +------------------+      +------------------+
         ^                                                                                  |
         |                           reads & filters dataset                               |
         +-----------------------------------------------------------------------------------+
         |
         v
+------------------+
| Slack #local-leads|
| Formatted alert  |
| per qualifying   |
| neighborhood     |
+------------------+

Why this approach works well for local lead routing

The AI agent approach is especially effective because filtering logic does not need to be written in advance or maintained as code. You adjust the criteria conversationally. If the roofing company decides to lower the homeowner threshold to 45% for a quieter week, you change one line in the prompt. No code deployment required.

The Apify MCP server also supports output schema inference, meaning Claude or Cursor understands the structure of the Nextdoor Scraper dataset before the run completes. That makes it easier for the agent to write accurate filter logic against fields like percentageHomeowners, averageIncome, and residentsCount without needing to inspect a raw JSON file first.

---

7. What the end result looks like in both paths

Path A: What the no-code Slack notification looks like

When a Nextdoor Scraper run finishes, the built-in Slack integration posts a notification automatically to your chosen channel. The message includes:

• The Actor name and run status
• A direct link to the dataset in Apify Console
• The run duration and the number of items stored

Your sales team opens Slack, sees the notification, and clicks through to the dataset to review results. No CSV downloads, no email chains, no delayed handoffs.

For teams that run the scraper on a schedule (e.g. every Monday morning before the weekly sales meeting), this turns a manual check-in into a reliable, automated briefing.

Path B: What the AI agent prompt workflow looks like

With the Apify MCP server connected to Claude or Cursor, the agent runs the full pipeline from one prompt. Here is what a real output message from Claude might look like after processing a Nextdoor Scraper dataset with a 50% homeowner filter:

+--------------------------------------------------------------+
|  #local-leads                                       [Slack]  |
+--------------------------------------------------------------+
|  🏡 High-intent lead: North Miami, FL                        |
|  Homeowner share: 54%  |  Avg income: $48k                   |
|  Residents: 59,854     |  Affordability: 82/100              |
|  Nextdoor page: https://nextdoor.com/city/north-miami--fl/   |
|                                                              |
|  🏡 High-intent lead: Bellbrook, OH                          |
|  Homeowner share: 61%  |  Avg income: $52k                   |
|  Residents: 7,009      |  Affordability: 91/100              |
|  Nextdoor page: https://nextdoor.com/city/bellbrook--oh/     |
+--------------------------------------------------------------+

In the Lake Rock Ventures pilot, switching from manual CSV review to the Apify MCP server + Claude workflow reduced the time from data collection to campaign briefing from 48 hours to under 10 minutes, while narrowing outreach to high-ownership areas only.

---

7. Wrapping up

Static data collection is no longer sufficient for modern local marketing and lead generation operations. By replacing manual CSV exports with an automated pipeline powered by Nextdoor Scraper and Apify MCP connectors, you can bridge the gap between web data extraction and real-time sales execution.

With this architecture, you benefit from:

• Hyper-local precision: Extracting structured resident counts, homeowner ratios, and income signals from public Nextdoor pages.
• Predictable cost scaling: Leveraging Pay-Per-Event pricing to pay strictly for successful record extractions.
• Zero glue-code overhead: Eliminating third-party integration tools and AWS Lambda scripts by using Apify MCP connectors.
• Instant lead velocity: Routing high-intent local opportunities straight to your sales team's Slack channel in seconds.

Ready to automate your local lead routing? Try Nextdoor Scraper in the Apify Store, connect your Slack workspace via Apify MCP connectors, and start turning public neighborhood signals into real-time sales momentum today.