# NASAA EFD Franchise Registration Scraper (`parseforge/nasaaefd-scraper`) Actor

Scrapes franchise registration records from the NASAA Electronic Filing Depository by keyword or full directory crawl. Returns each franchise as a flat row with optional detail-page fields including contacts and state filings.

- **URL**: https://apify.com/parseforge/nasaaefd-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 29 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.99 / 1,000 result items

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### NASAA EFD Franchise Registration Scraper

**Scrape franchise registration data from the NASAA Electronic Filing Depository.** Get franchisor names, contacts, state filings, and FDD history for any brand or the entire directory. Export to CSV, JSON, Excel, or XML.

The NASAA EFD is the official public database where franchisors file their Franchise Disclosure Documents and state registrations. Searching it manually means clicking through paginated lists and detail pages one by one. This Actor reads the public directory for you, returning every matched franchise registration in a structured dataset.

| Who uses it | What they scrape NASAA EFD for |
|---|---|
| Franchise brokers | Build a lead list of active franchisors with current state registrations. |
| Competitive intelligence analysts | Track which brands are expanding into new states and when they filed. |
| Franchise attorneys | Monitor FDD filing activity and registration statuses for due diligence. |
| Market researchers | Map the franchise landscape by industry, state coverage, and filing dates. |

### What it does

This Actor collects franchise registration records from the NASAA EFD by keyword search or full directory crawl, and returns each franchise as a flat row with optional detail-page fields.

- 🔍 **Keyword search:** find franchises by brand name, franchisor name, EFDID, or state file number.
- 🌐 **Full directory crawl:** enable Get All Franchises to collect every registration in the database.
- 📋 **Listing-only mode:** disable detail pages for fast, high-level collection of names and IDs.
- 📄 **Detail-page enrichment:** fetch full addresses, contacts, and per-state registration records.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with NASAA EFD data

**📊 Build a franchise lead list.**

A broker runs a keyword search for 'pizza' with detail pages enabled, then exports a CSV of franchisor names, contact emails, and active state registrations to prioritize outreach.

**🗺️ Track state-by-state expansion.**

A competitive analyst scrapes the full directory monthly, filters by state filing date, and identifies which brands are entering new markets.

**⚖️ Audit FDD filing activity.**

A franchise attorney searches for a specific franchisor by EFDID, collects all historical registration records, and reviews filing gaps or lapsed states.

**📈 Map the franchise industry.**

A researcher runs a full crawl without detail pages to get a fast count of active franchises by industry code, then samples detail pages for deeper analysis.

### Why choose this scraper

|  | What you get |
|---|---|
| **No manual clicking** | The Actor paginates search results and opens detail pages automatically. |
| **Structured output** | Every franchise returns as a flat row, ready for analysis in any spreadsheet. |
| **Full or filtered** | Target one brand or collect the entire NASAA EFD directory in a single run. |
| **Residential proxy built in** | Pre-configured US residential proxy avoids the site's bot-blocking and CAPTCHAs. |

### How it compares

No other Store actor targets NASAA EFD the same way, so the honest comparison is with the alternatives teams actually weigh.

| | NASAA EFD Franchise Registration Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When NASAA EFD changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor with a keyword search or a full directory crawl, and choose whether to fetch detail pages for each franchise. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "keyword": "pizza",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "keyword": "pizza",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

### Pricing

Pay-per-result: **$0.01734 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.73 |
| 1,000 results | $17.34 |
| 10,000 results | $173.40 |

#### Run start fee (from October 3, 2026)

The price per result does not change. The small fee for starting a run is billed by the platform itself as the standard start event, scaled to the memory the run uses.

| Event | Price | Charged when |
|---|---|---|
| `apify-actor-start` | $0.005 per GB of run memory | the run starts |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [NASAA EFD Franchise Registration Scraper](https://apify.com/parseforge/nasaaefd-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to NASAA EFD through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/nasaaefd-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your keyword is at least three characters long and spelled correctly. If you are using 'Get All Franchises,' the run may take longer but should return results. Verify that your proxy is set to US residential, as datacenter IPs are often blocked.

**The Actor is stuck or returning CAPTCHA pages.**

The NASAA EFD site aggressively blocks datacenter traffic. Ensure your proxy configuration is set to US residential. The default prefill already selects this, but double-check that it was not changed.

**I only got 100 records but I am a paid user.**

The 'Maximum franchise registrations' field defaults to a low number for testing. Increase the 'maxItems' value up to 1,000,000 to collect more records.

**Detail page fields are empty in my output.**

Make sure the 'Include Detail Pages' checkbox is enabled. If it is off, the Actor only collects the summary fields from the search results listing.

**The run is taking a very long time.**

A full directory crawl with detail pages enabled will open thousands of pages. For faster results, disable 'Include Detail Pages' to collect listing-only data, or reduce the 'maxItems' count.

### FAQ

| Question | Answer |
|---|---|
| What is the NASAA EFD? | The Electronic Filing Depository is a public database run by the North American Securities Administrators Association where franchisors file their Franchise Disclosure Documents and state registration notices. It covers filings across multiple US states. |
| Do I need a login or API key to scrape the NASAA EFD? | No. The Actor reads the public-facing website. You do not need an account, API key, or any credentials. |
| What data does this Actor return? | It returns franchise registration records including franchisor name, brand name, EFDID, industry type, state filings, and contact information. The exact fields depend on whether you enable detail pages. |
| Can I scrape the entire NASAA EFD database? | Yes. Enable the 'Get All Franchises' option and the Actor will run broad searches to collect every available registration. This takes longer but returns the full directory. |
| How do I search for a specific franchise? | Enter a keyword in the 'Search term for franchises' field. You can search by brand name, franchisor legal name, EFDID, or state file number. The minimum search term length is three characters. |
| What is the difference between listing-only and detail-page mode? | Listing-only mode collects the summary fields visible on the search results page, such as brand name and EFDID. Detail-page mode opens each franchise's full page to collect addresses, contacts, and per-state registration records. |
| Why do I need a residential proxy? | The NASAA EFD site uses AWS WAF and CloudFront, which block datacenter IP addresses and serve CAPTCHAs on the search page. A US residential proxy routes your requests through real home IPs to avoid these blocks. |
| How many franchise records can I scrape? | Free Apify users are limited to 100 records. Paid users can set a maximum up to 1,000,000 records per run. |
| Can I scrape specific franchise detail URLs directly? | Yes. Paste one or more NASAA EFD detail page URLs into the 'Start URLs' field. The Actor will scrape only those pages and ignore any search filters. |
| What export formats are supported? | You can export your dataset as CSV, JSON, Excel, or XML from the Apify platform. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by North American Securities Administrators Association, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Direct franchise detail URLs to scrape. Use this OR the search filters below, not both.

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

Free users: Limited to 100. Paid users: Optional, max 1,000,000

## `keyword` (type: `string`):

Search franchises by name, franchisor name, EFDID, or state file number. Minimum 3 characters.

## `getAllFranchises` (type: `boolean`):

Collect all franchise registrations in the database by running broad searches. Takes longer but returns the full dataset.

## `includeDetails` (type: `boolean`):

Fetch full franchise details including address, contacts, and state registrations. Disable for faster listing-only collection.

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

Residential US proxy is strongly recommended — the site (AWS WAF/CloudFront) blocks datacenter IPs and CAPTCHA-gates the franchise search.

## Actor input object example

```json
{
  "maxItems": 10,
  "keyword": "pizza",
  "getAllFranchises": false,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Complete dataset of franchise registration records with all fields

# 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 = {
    "maxItems": 10,
    "keyword": "pizza",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nasaaefd-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 = {
    "maxItems": 10,
    "keyword": "pizza",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nasaaefd-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 '{
  "maxItems": 10,
  "keyword": "pizza",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call parseforge/nasaaefd-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/nasaaefd-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/psaBOW0oc2SbB9Nah/builds/QTgjXYmcddUoc3r95/openapi.json