# FastPeopleSearch Scraper: Phones, Emails & Addresses Skip Trace (`memo23/fastpeoplesearch-scraper`) Actor

Run many FastPeopleSearch lookups in one actor run — names, reverse phone, reverse address. You pay only for people written to the dataset, not for 404s. Rows include decoded emails, typed phones, addresses and relatives. Optional Email-1/Phone-1 columns and a resume cursor. No proxy setup.

- **URL**: https://apify.com/memo23/fastpeoplesearch-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, Business, MCP servers
- **Features:** Limited permissions
- **Stats:** 399 total users, 56 monthly users, 94.4% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 person records

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

## FastPeopleSearch Scraper — Phones, Emails & Addresses

Turn a list of names, phones, or street addresses into full US person records in one run.
Search FastPeopleSearch.com by name (with optional city/state), run reverse phone or reverse address lookups, or paste any FastPeopleSearch URL — and get structured rows with phone numbers, email addresses, current + past addresses, relatives, associates, and employment history. You pay only for people written to the dataset.

### Why Use This Scraper?

- ✅ Batch lists — `searches[]` runs many names, phones, or addresses in one run
- ✅ Email addresses included and decoded to plain text (most FastPeopleSearch scrapers skip these)
- ✅ Phone numbers with carrier, line type, and first-reported date
- ✅ Charged only for people actually written to the dataset — empty lookups cost nothing extra
- ✅ Flattened CRM columns (`Email-1`, `Phone-1`, …) for Sheets / skip-trace exports
- ✅ Resume cursor — continue a large crawl without re-billing people you already have
- ✅ Works out of the box — no proxy setup, no login, no API key

### Overview

The FastPeopleSearch Scraper is built for skip tracers, real-estate investors, lead-generation teams, and researchers who need structured US people data without copying it off the site by hand.

The output is person-shaped rows. Whatever you start from — a name search, a phone number, an address, or a pasted URL — the dataset is a stream of person records, one row per profile. A reverse phone lookup that matches three people produces three person rows.

A run needs no setup on your side: no proxy configuration, no account, no API key. Pages that fail to load are retried automatically, so a temporary error rarely costs you a row.

### Coming from another skip-trace actor?

| Complaint we keep seeing on the category leader | What this actor does |
|---|---|
| Charged for “Person Not Found” / 404s | Billing is `apify-default-dataset-item` — a row has to land in the dataset |
| One name per run, 189 runs for a list | Pass `searches` — one run, many lookups |
| No emails | Emails come back as plain text whenever the profile lists them |
| $0.10 actor-start tax | Start event is $0.005 |
| Re-paying for page 1 of a huge name search | Paste `resumeCursor` from the previous run |

### Supported Inputs

#### Search modes

| Mode | You provide | Example |
|---|---|---|
| Name search | `firstName`, `lastName`, optional `city` + `state` | John Smith in NY |
| Reverse phone | `phone` (any format) | `(206) 592-2882` |
| Reverse address | `address`, `city`, `state`, optional `zip` | 123 Main St, Dallas, TX |

#### URL types (advanced)

| URL type | Pattern | Example |
|---|---|---|
| Name listing | `/name/{first}-{last}_{city}-{st}` | `https://www.fastpeoplesearch.com/name/john-smith_ny` |
| Reverse phone | `/{AAA-BBB-CCCC}` | `https://www.fastpeoplesearch.com/206-592-2882` |
| Reverse address | `/address/{street}_{city}-{st}` | `https://www.fastpeoplesearch.com/address/123-main-st_dallas-tx` |
| Person profile | `/{name}_id_G{id}` | `https://www.fastpeoplesearch.com/amanda-smith_id_G4156490107428859261` |

#### Copy-pasteable startUrls

```json
{
  "startUrls": [
    "https://www.fastpeoplesearch.com/name/john-smith_ny",
    "https://www.fastpeoplesearch.com/206-592-2882",
    "https://www.fastpeoplesearch.com/amanda-smith_id_G4156490107428859261"
  ],
  "maxItems": 20
}
```

#### Unsupported inputs

- ❌ URLs outside `fastpeoplesearch.com`
- ✅ A CSV file or shared Google Sheet as the search list (`csvUrl`)
- ❌ Anything behind a login or paywall (the site has none for the data this actor collects)

### Use Cases

| Audience | Use case |
|---|---|
| **Skip tracers** | Locate current addresses and working phone numbers from a name or an old address |
| **Real-estate investors** | Reverse-address lookups on distressed properties to reach the owner directly |
| **Lead-gen teams** | Turn sparse contact lists into full records with phones and emails |
| **Collections / legal** | Verify identity, address history, and known relatives before contact |
| **Researchers** | Bulk-export people data for genealogy or demographic analysis |

### How It Works

![How FastPeopleSearch Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-fastpeoplesearch.png)

1. **Input** — pick a search mode and fill the matching fields, or paste FastPeopleSearch URLs
2. **Load reliably** — every page is retried automatically until it loads, with no proxy setup on your side
3. **Walk the results** — the actor pages through the listing and opens each person profile concurrently
4. **Parse the record** — phones, emails (decoded from obfuscation), addresses, relatives, associates, employment
5. **Output** — one row per person, exportable as JSON, CSV, or Excel

### Input Configuration

#### Input fields

| Field | Type | Required | Notes |
|---|---|---|---|
| `searchMode` | `string` enum | optional | `name` (default), `phone`, or `address`. Ignored when `startUrls` is set |
| `firstName` | `string` | for name mode | First name to search |
| `lastName` | `string` | for name mode | Last name to search |
| `city` | `string` | optional / address mode | Narrows name searches; required for address mode |
| `state` | `string` enum | optional / address mode | Two-letter US state (50 states + DC) |
| `phone` | `string` | for phone mode | Any format — digits are extracted |
| `address` | `string` | for address mode | Street part, e.g. `123 Main St` |
| `zip` | `string` | optional | Makes address mode more precise |
| `searches` | `array<object>` | optional | Batch: one object per lookup (same fields as a single search). Replaces the top-level search when set |
| `csvUrl` | `string` | optional | Link to a CSV file or a Google Sheet shared with anyone who has the link. Columns: First Name, Last Name (or Name), Phone, Address, City, State, Zip. Each row is one search, added to `searches`; unusable rows are skipped and listed in the log |
| `maxItemsPerSearch` | `integer` | optional | Cap per `searches` entry. Default `5` when more than one search is passed |
| `flattenedOutput` | `boolean` | optional | Add `Email-1` / `Phone-1` spreadsheet columns. Default `false` |
| `resumeCursor` | `string` | optional | Continue a previous run without re-billing delivered people |
| `startUrls` | `array<string>` | optional | FastPeopleSearch URLs; overrides the search fields |
| `maxItems` | `integer` | optional | Hard cap on person records. Default `10` |
| `maxConcurrency` | `integer` | optional | Parallel page fetches (searches and profiles). Default `5` |
| `storedRecordMaxAgeDays` | `integer` | optional | Return a person's record from this Actor's own store when it was fetched no more than this many days ago, instead of opening their page again. Default `30`; `0` fetches every record live |
| `fillMissingContacts` | `boolean` | optional | When a person's FastPeopleSearch page cannot be loaded, look the same person up in another public people-search source and return them with phones and emails. Used only when name, age, city and relatives agree; such rows carry `contactsSource: "secondary"`. Default `true`; `false` returns FastPeopleSearch data only |

#### Common scenarios

**1. Name search narrowed to a state**

```json
{
  "searchMode": "name",
  "firstName": "John",
  "lastName": "Smith",
  "state": "NY",
  "maxItems": 25
}
```

**2. Reverse phone lookup**

```json
{
  "searchMode": "phone",
  "phone": "(206) 592-2882",
  "maxItems": 5
}
```

**3. Reverse address lookup**

```json
{
  "searchMode": "address",
  "address": "6507 Steilacoom Blvd SW",
  "city": "Lakewood",
  "state": "WA",
  "maxItems": 10
}
```

**4. Batch list (many lookups, one run)**

```json
{
  "searches": [
    { "searchMode": "name", "firstName": "Jane", "lastName": "Doe", "city": "Dallas", "state": "TX" },
    { "searchMode": "phone", "phone": "(206) 592-2882" },
    { "searchMode": "address", "address": "123 Main St", "city": "Austin", "state": "TX" }
  ],
  "maxItems": 50,
  "maxItemsPerSearch": 5,
  "flattenedOutput": true
}
```

### Output Overview

Each dataset item is one person record containing:

- **Identity** — `fullName`, `firstName`, `lastName`, `age`, `bornMonthYear`, `akas[]`
- **Contact** — `phones[]` (number, line type, carrier, first-reported date, primary flag), `phoneDetails[]` (the same phones in the shape the TruePeopleSearch actor uses), `emails[]`, `primaryPhone`
- **Location** — `currentAddress` (street/city/state/zip/county + since-date), `coordinates`, `pastAddresses[]` with recorded dates
- **Property** — `currentAddressPropertyDetails` (square feet, year built, estimated value, last sale, occupancy type)
- **Network** — `relatives[]` and `associates[]`, each with name, age, and profile URL
- **Work** — `currentEmployment[]` and `workExperience[]` (employer, title, location)
- **Query echo** — `query.inputGiven`, `Search Option`, `Input Given` (so a batch row joins back to the lookup that produced it)
- **Meta** — `personId`, `profileUrl`, `maritalStatusText`, `scrapedAt`, `recordFetchedAt` (when the record was read from FastPeopleSearch; earlier than `scrapedAt` only for a record returned from the store)

Field availability follows the site: a profile without a listed email produces an empty `emails` array, not a missing run.

### Output Samples

#### Reverse address start, trimmed

```jsonc
{
  "type": "person",
  "personId": "G5374097278778066177",
  "profileUrl": "https://www.fastpeoplesearch.com/mary-huff_id_G5374097278778066177",
  "fullName": "Mary L Huff",
  "firstName": "Mary",
  "lastName": "Huff",
  "age": 71,
  "bornMonthYear": "October 1954",
  "currentAddress": {
    "fullAddress": "6507 Steilacoom Blvd SW, Lakewood, WA, 98499",
    "street": "6507 Steilacoom Blvd SW",
    "city": "Lakewood",
    "state": "WA",
    "zip": "98499",
    "county": "Pierce County",
    "since": "January 2012"
  },
  "coordinates": { "latitude": 47.176693, "longitude": -122.524788 },
  "currentAddressPropertyDetails": {
    "bedrooms": "3",
    "squareFeet": "1,438",
    "yearBuilt": "1928",
    "estimatedValue": "$468,000",
    "occupancyType": "Owner Occupied"
  },
  "phones": [
    {
      "number": "(253) 380-5662",
      "type": "Wireless",
      "carrier": "T-Mobile USA Inc",
      "firstReported": "September 2025",
      "isPrimary": true
    }
  ],
  "primaryPhone": "(253) 380-5662",
  "emails": ["marylhuff@gmail.com", "mary.huff@intel.com"],
  "akas": ["Mary Huff", "Mary L Smith"],
  "pastAddresses": [
    {
      "fullAddress": "120 Walzer Rd Rochester NY 14622",
      "city": "Rochester",
      "state": "NY",
      "county": "Monroe County",
      "recordedDate": "June 2017"
    }
  ],
  "relatives": [
    { "name": "Amanda Smith", "age": "Age 46 (May 1980)", "profileUrl": "https://www.fastpeoplesearch.com/amanda-smith_id_G4156490107428859261" }
  ],
  "currentEmployment": [
    { "employer": "WASHINGTON STATE DEPARTMENT OF ECOLOGY", "title": "FLOODPLAIN MANAGEMENT UNIT SUPERVISOR", "location": "Salt Lake City, UT" }
  ],
  "scrapedAt": "2026-09-02T20:39:30.355Z"
  /* pastAddresses, relatives, associates, workExperience trimmed */
}
```

### Key Output Fields

#### Identity

- `fullName`, `firstName`, `lastName`, `age`, `bornMonthYear`, `akas[]`, `personId`, `profileUrl`

#### Phones

- `phones[].number`, `phones[].type` (Wireless / Landline / Voip), `phones[].carrier`, `phones[].firstReported`, `phones[].isPrimary`, `primaryPhone`
- `phoneDetails[]` — `number`, `type`, `carrier`, `firstReported`, `lastReported`, `isPrimary`, `isInactive`: one phone shape shared with the TruePeopleSearch actor, so both sources map the same way. FastPeopleSearch shows no last-reported month or inactive flag, so those stay `null` / `false` here.

#### Emails

- `emails[]` — plain-text addresses, decoded from the site's obfuscation

#### Addresses

- `currentAddress.{street, city, state, zip, county, since}`, `coordinates.{latitude, longitude}`
- `pastAddresses[].{fullAddress, street, city, state, zip, county, recordedDate}`
- `currentAddressPropertyDetails.{squareFeet, yearBuilt, estimatedValue, lastSaleAmount, occupancyType, …}`

#### People network

- `relatives[].{name, age, profileUrl}`, `associates[].{name, age, profileUrl}`

#### Employment

- `currentEmployment[].{employer, title, location}`, `workExperience[].{employer, title}`

### FAQ

#### What do I get on the free Apify plan?

Free-plan runs read the FastPeopleSearch search results only: each row has the person's name, age, current city and state, past cities and AKAs, the profile URL, and their relatives with names shortened. They do not open the person's page, so they return **no phone numbers, emails, street addresses or property details**, and every free row carries a `freePlanNote` field saying so. Pages are fetched through Apify Proxy in your own Apify account, so a free run uses your account's proxy allowance. Any paid Apify plan returns the full record for every person.

#### Is every record fetched live?

By default a person this Actor fetched in the last 30 days comes back from its own store instead of being fetched again, which is much faster. `recordFetchedAt` on each row says when its record was read. Set `storedRecordMaxAgeDays` to `0` to fetch every record live, or lower it for fresher data. Records are billed the same either way.

#### Which URLs are supported?

Any `fastpeoplesearch.com` URL: name listings (`/name/john-smith_ny`), reverse phone pages (`/206-592-2882`), reverse address pages (`/address/...`), and direct person profiles (`/{name}_id_G{id}`). URLs on other hosts are not.

#### Do I get person rows or search-result rows?

Person rows, always. Listing pages are only used to find profiles; every dataset item is a full parsed profile.

#### Are emails always present?

No — they appear when the site lists them for that person. In testing, most adult profiles carried 5–12 addresses, but some have none. Emails that the site obfuscates are decoded to plain text automatically.

#### How do I search a whole state vs. one city?

Set `state` alone for a state-wide search, or `city` + `state` to narrow it. Leaving both empty searches nationwide, which is broad — cap it with `maxItems`.

#### Can I paste multiple searches into one run?

Yes. Put them in `searches` (one object per name / phone / address). Each entry is walked until `maxItemsPerSearch` (default 5 in batch) or the global `maxItems`. `startUrls` still works if you already have listing links.

#### How do I continue a run without paying twice?

When `maxItems` stops the crawl, the actor logs `RESUME_CURSOR` and writes it to the default key-value store. Paste that string into `resumeCursor` on the next run. Already-delivered person IDs are skipped and not billed again.

#### Can I scrape private or paywalled data?

No. The actor reads only the public profile pages; there is no login and no paid-content access.

#### Why do requests take longer than a normal scraper?

Every page is checked and retried automatically until it comes back complete, which takes longer than a single request. A page typically takes 2–10 seconds. Searches in a batch run in parallel, and concurrency (default 5) keeps total run time reasonable.

#### What happens when a page does not load?

The actor retries each page several times automatically. Persistent failures are logged and skipped, so a run never hangs on one bad URL. An address or name the site has no page for counts as "no records" right away, without retries.

### Support

Found a bug or have a feature request? Open an issue on the actor's Issues tab in the Apify Console, or email **muhameddidovic@gmail.com**.

### Additional Services

Need a custom export shape, monitoring on a schedule, or the same data from another people-search site? I do tailored work — drop me a line at **muhameddidovic@gmail.com**.

### Explore More Scrapers

If you found this useful, you might also like:

- [**TruePeopleSearch Scraper**](https://apify.com/memo23/truepeoplesearch-people-search-scraper) — same pipeline on TruePeopleSearch.com
- [**Realtor.com Agents Scraper**](https://apify.com/memo23/realtor-search-cheerio) — all US real-estate agents, no 3k limit
- [**Zillow Agents Leads Scraper**](https://apify.com/memo23/zillow-agents-leads-scraper-ppe) — agent lead lists from Zillow

Full list at [apify.com/memo23](https://apify.com/memo23).

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/fastpeoplesearch-scraper`).

**Purpose:** US people search on FastPeopleSearch.com — name, reverse-phone, reverse-address, or a `searches[]` batch; returns one row per person including decoded emails, typed phones, address history, relatives, and associates.

**Minimal input:**

```json
{ "searchMode": "name", "firstName": "John", "lastName": "Smith", "state": "NY", "maxItems": 5 }
```

**Batch input:**

```json
{ "searches": [{ "searchMode": "phone", "phone": "2065922882" }, { "searchMode": "name", "firstName": "Jane", "lastName": "Doe", "state": "TX" }], "maxItems": 10, "flattenedOutput": true }
```

**Output:** one dataset row per person — `fullName`, `firstName`, `lastName`, `age`, `phones[]`, `phoneDetails[]` (line type, carrier, first reported), `primaryPhone`, `emails[]`, `currentAddress`, `query.inputGiven`, plus optional `Email-1` / `Phone-1` / `Phone-1 Type` columns when `flattenedOutput` is true.

**Behaviors an agent should know:**

- Always set `maxItems`. In batch mode also set `maxItemsPerSearch` (defaults to 5).
- `searches[]` runs many lookups in one run. `startUrls` overrides both `searches` and the single search fields.
- Also accepted as input field names: `name` (`"Full Name"` or `"Full Name; City, ST ZIP"`), `street_citystatezip` (`"3828 Double Oak Ln; Irving, TX 75061"`), `phone_number` (any format), `email` and `max_results` (records per search). Each takes an array or a single string; every name, address and phone runs as its own search in one run. Emails are not searched.
- Billing is per person record written; empty lookups and resume skips are not billed.
- If a run hits `maxItems`, read `RESUME_CURSOR` from the default key-value store and pass it back as `resumeCursor`.
- Pages are retried automatically; expect 3–30 s per page.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by FastPeopleSearch.com or its operators. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available people-search pages — no authenticated endpoints, paid features, or content behind any login wall. People-search data is sensitive: users are responsible for ensuring their use complies with FastPeopleSearch.com's Terms of Service, the Fair Credit Reporting Act (this actor is not a consumer reporting agency and its output must not be used for FCRA-regulated purposes such as employment, credit, or tenancy screening), applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

fastpeoplesearch scraper, scrape fastpeoplesearch, fastpeoplesearch API, fastpeoplesearch.com scraper, Apify fastpeoplesearch, people search scraper, reverse phone lookup API, reverse address lookup scraper, skip tracing tool, skip tracing data, people finder API, phone number lookup scraper, email finder people search, address history data, relatives and associates data, US public records scraper, contact enrichment data, real estate lead generation, property owner lookup, truepeoplesearch alternative

# Actor input Schema

## `searchMode` (type: `string`):

How to search: `name` (first + last name, optionally narrowed by city/state), `phone` (reverse phone lookup), or `address` (who lives at a street address). Ignored when Start URLs are provided.

## `firstName` (type: `string`):

First name of the person to search for (required for name mode).

## `lastName` (type: `string`):

Last name of the person to search for (required for name mode).

## `city` (type: `string`):

City — optional for name mode (narrows results), required for address mode.

## `state` (type: `string`):

Two-letter US state abbreviation (e.g. NY, CA). Narrows name searches; required for address mode.

## `phone` (type: `string`):

Phone number for reverse lookup (required for phone mode). Any format works — digits are extracted, e.g. `(555) 123-4567` or `5551234567`.

## `address` (type: `string`):

Street address for reverse lookup (required for address mode), e.g. `123 Main St`. Combine with City and State.

## `zip` (type: `string`):

Optional ZIP code — makes address mode more precise.

## `searches` (type: `array`):

One object per lookup. Each entry uses the same fields as a single search (`searchMode` + name / phone / address). When this array is set, it replaces the single top-level search. Empty lookups are not billed. Up to 1,000 entries per run for paying users and 1 for free runs; a 1,000-entry run takes several hours, so raise the run timeout to match. Example: \[{"searchMode":"name","firstName":"Jane","lastName":"Doe","state":"TX"},{"searchMode":"phone","phone":"2065922882"}].

## `csvUrl` (type: `string`):

Link to a CSV file, or a Google Sheet shared with anyone who has the link, with one lookup per row. Recognised columns: First Name and Last Name (or Name), Phone, Address, City, State, Zip, and optionally Search Mode. A row with a phone number is searched by phone, otherwise by address (with city and state), otherwise by name. Rows that cannot be searched are skipped and listed in the log. The rows join Searches and, like Searches, replace the single search above. Set Maximum person records to about 3 x the number of rows. If the file cannot be used and there is no other search, the run ends without searching.

## `maxItemsPerSearch` (type: `integer`):

Cap on person records kept for each entry in `searches`. Default is 2 when you pass more than one search, otherwise the global Maximum person records applies. Stops a common name from eating the whole run.

## `flattenedOutput` (type: `boolean`):

When enabled, each row also gets CRM-style columns (`Email-1`…`Email-5`, `Phone-1` + type/carrier, `Street Address`, `Input Given`, `Person Link`) so a CSV export drops into Sheets the same way skip-trace tools do. Nested arrays stay on the row.

## `storedRecordMaxAgeDays` (type: `integer`):

Person records this Actor has fetched before are kept. When a person turns up again, their stored record is returned if it was fetched no more than this many days ago, instead of opening their page again. Much faster; set 0 to always fetch every record live. Each returned row says when its record was fetched in `recordFetchedAt`.

## `fillMissingContacts` (type: `boolean`):

On by default. When a person's FastPeopleSearch page cannot be loaded, look the same person up in another public people-search source and return them with their phones and emails. A match is used only when name, age, city and relatives agree; otherwise the person is skipped. Rows filled this way have `contactsSource` set to `secondary`. Turn off to receive FastPeopleSearch data only.

## `resumeCursor` (type: `string`):

Paste the cursor from a previous run (logged as RESUME_CURSOR and saved in the key-value store) to continue without fetching or billing people you already received. Leave empty for a fresh crawl.

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

Full fastpeoplesearch.com URLs to crawl. Listing and person profile URLs are auto-classified; mix both in the same array if useful. Up to 1,000 entries per run for paying users and 1 for free runs.

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

Hard cap on the number of person records scraped. Values above 3,000 are clamped to 3,000 per run (25 on the free plan). For a batch, set it to about 3 x the number of searches so the last searches are not cut off. Broad name searches can return hundreds of matches; use this cap to limit billing.

## `maxConcurrency` (type: `integer`):

Maximum number of pages (searches and person profiles) fetched in parallel. Default 5.

## Actor input object example

```json
{
  "searchMode": "name",
  "firstName": "John",
  "lastName": "Smith",
  "state": "NY",
  "searches": [],
  "flattenedOutput": false,
  "storedRecordMaxAgeDays": 30,
  "fillMissingContacts": true,
  "maxItems": 10,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Dataset of person records with phones, emails, address history, relatives, associates and employment history.

# 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 = {
    "firstName": "John",
    "lastName": "Smith",
    "state": "NY",
    "searches": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/fastpeoplesearch-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 = {
    "firstName": "John",
    "lastName": "Smith",
    "state": "NY",
    "searches": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/fastpeoplesearch-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 '{
  "firstName": "John",
  "lastName": "Smith",
  "state": "NY",
  "searches": []
}' |
apify call memo23/fastpeoplesearch-scraper --silent --output-dataset

```

## MCP server setup

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