# NAPFA Advisor Scraper — Fee-Only RIA Leads, Email & Phone (US) (`scrapersdelight/napfa-advisor-scraper`) Actor

Scrape the NAPFA fee-only financial advisor directory by location — advisor name, firm, email, phone, website, CFP designations, specialties, address & coordinates. Public data, no login. Export JSON/CSV.

- **URL**: https://apify.com/scrapersdelight/napfa-advisor-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$12.00 / 1,000 per advisor returneds

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

## NAPFA Advisor Scraper

Export the [NAPFA](https://www.napfa.org/find-an-advisor) fee-only advisor directory as a clean, ready-to-use lead list — advisor name, firm, email, phone, website, CFP designations and specialties, by location.

NAPFA (the National Association of Personal Financial Advisors) is the roster of ~4,000 **fee-only** advisors — the exact, pre-qualified segment that RIA/wealth-tech vendors and advisor recruiters want to reach.

### What you get

One row per advisor (or per firm — your choice). Each advisor row includes:

- **Identity** — `first_name`, `last_name`, `full_name`, `role`, `designations` (CFP, CDFA, MBA…), `member_id`
- **Contact** — `email`, `consumer_referral_email`, `phone`
- **Firm** — `firm_name`, `firm_website`, `firm_email`, `firm_phone`, `firm_id`
- **Location** — `address_line1/2`, `city`, `state`, `zip`, `country`, `lat`, `lon`
- **Profile** — `planning_specialties`, `additional_information`, `expertises[]`, `industry_start_date`, `napfa_start_date`, `years_experience`, `photo_url`
- **Provenance** — `source_url`, `matched_location`, `scraped_at`

**Contact coverage (honest, measured on a live sample):** advisor *direct* email is present on ~65% of members and work phone on ~98%; every row also carries the **firm email, firm phone and firm website as a 100% fallback**, so no advisor row ships without a way to reach the firm. We do **not** claim a personal email for every advisor.

### Use cases

- **RIA / wealth-tech outbound** — sell portfolio, CRM, planning, tax or compliance software (Wealthbox, RightCapital, Holistiplan-class) to verified fee-only firms.
- **Advisor recruiting** — source fee-only CFPs by geography and specialty.
- **RIA M&A sourcing** — build a target list of independent fee-only practices for roll-ups/aggregators.
- **Competitive mapping** — chart fee-only firms by market, specialty and fee structure.

### How it works

Searches the public NAPFA "Find an Advisor" directory by location (ZIP or "City, ST"), one request per location, and reads the advisor data straight from the page. Dedupes by advisor (`member_id`) and firm (`firm_id`) across locations. No login, no account — public professional-directory data. Leave `locations` empty to sweep a bundled list of ~2,900 US cities (the whole roster); or pass specific ZIPs/cities to target a market.

### Input

```json
{
  "locations": ["10001", "Boston, MA", "94104"],
  "recordType": "advisor",
  "requireEmail": false,
  "maxItems": 500
}
````

- `locations` — ZIPs or "City, ST"; empty = full-US sweep.
- `recordType` — `advisor` (default) or `firm`.
- `requireEmail` — drop rows with no email at all.
- `maxItems` — cost guard (default 500; 0 = everything).

### Output (one advisor record)

```json
{
  "member_id": 112733,
  "first_name": "Jeremy",
  "last_name": "Chambers",
  "full_name": "Jeremy Chambers",
  "role": "NAPFA-Registered Financial Advisor",
  "designations": ["CFP"],
  "designations_str": "CFP",
  "email": "jeremy@thehourlyadvisor.com",
  "phone": "(704) 609-0482",
  "firm_id": 51514,
  "firm_name": "the hourly advisor llc",
  "firm_website": "https://thehourlyadvisor.com",
  "firm_email": "jeremy@thehourlyadvisor.com",
  "firm_phone": "(704) 609-0482",
  "city": "Hoboken",
  "state": "NJ",
  "zip": "07030",
  "lat": 40.74338,
  "lon": -74.03509,
  "expertises": ["Hourly", "Investment Advice without Ongoing Management"],
  "napfa_start_date": "2024-08-08T17:03:17Z",
  "source_url": "https://www.napfa.org/find-an-advisor?q=10001",
  "matched_location": "10001",
  "scraped_at": "2026-07-07T00:00:00.000Z"
}
```

### Pricing

**Pay per record — $12 / 1,000 advisors** (~$0.012 each). These are verified, email-bearing B2B leads in a high-intent segment. Use `maxItems` to cap spend on any run.

### Legal / ethical note

This scrapes **public professional-directory** contact information that NAPFA publishes for advisors to be found by prospects. You are responsible for complying with NAPFA's Terms of Use and with **CAN-SPAM** and any applicable opt-out / privacy law when you contact these advisors.

# Actor input Schema

## `locations` (type: `array`):

ZIP codes or "City, ST" strings to search (each returns fee-only advisors within ~5 miles). Leave EMPTY to sweep a bundled list of ~2,900 US cities (the whole roster).

## `recordType` (type: `string`):

One row per advisor (richest lead — default) or one row per firm (with an advisor\_count).

## `requireEmail` (type: `boolean`):

Drop rows that have no email at all (neither advisor direct email nor the firm email fallback).

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

Cap on records returned this run (cost/speed guard). Default 500; set 0 for the whole scope.

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

Proxy settings. Datacenter is fine (the site has no anti-bot); flip to RESIDENTIAL as insurance if you ever see non-200s.

## Actor input object example

```json
{
  "locations": [
    "10001",
    "90071",
    "60602",
    "94104",
    "02110"
  ],
  "recordType": "advisor",
  "requireEmail": false,
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `records` (type: `string`):

The dataset of scraped NAPFA fee-only advisors (or firms), one item per record.

# 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 = {
    "locations": [
        "10001",
        "90071",
        "60602",
        "94104",
        "02110"
    ],
    "recordType": "advisor"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/napfa-advisor-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 = {
    "locations": [
        "10001",
        "90071",
        "60602",
        "94104",
        "02110",
    ],
    "recordType": "advisor",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/napfa-advisor-scraper").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 '{
  "locations": [
    "10001",
    "90071",
    "60602",
    "94104",
    "02110"
  ],
  "recordType": "advisor"
}' |
apify call scrapersdelight/napfa-advisor-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapersdelight/napfa-advisor-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NAPFA Advisor Scraper — Fee-Only RIA Leads, Email & Phone (US)",
        "description": "Scrape the NAPFA fee-only financial advisor directory by location — advisor name, firm, email, phone, website, CFP designations, specialties, address & coordinates. Public data, no login. Export JSON/CSV.",
        "version": "0.1",
        "x-build-id": "KL4Pip80nKpHfqi5S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~napfa-advisor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-napfa-advisor-scraper",
                "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/scrapersdelight~napfa-advisor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-napfa-advisor-scraper",
                "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/scrapersdelight~napfa-advisor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-napfa-advisor-scraper",
                "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",
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "ZIP codes or \"City, ST\" strings to search (each returns fee-only advisors within ~5 miles). Leave EMPTY to sweep a bundled list of ~2,900 US cities (the whole roster).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recordType": {
                        "title": "Record type",
                        "enum": [
                            "advisor",
                            "firm"
                        ],
                        "type": "string",
                        "description": "One row per advisor (richest lead — default) or one row per firm (with an advisor_count).",
                        "default": "advisor"
                    },
                    "requireEmail": {
                        "title": "Require email",
                        "type": "boolean",
                        "description": "Drop rows that have no email at all (neither advisor direct email nor the firm email fallback).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on records returned this run (cost/speed guard). Default 500; set 0 for the whole scope.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Datacenter is fine (the site has no anti-bot); flip to RESIDENTIAL as insurance if you ever see non-200s.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```