# Signal NFX Investor Profiles Scraper (`automation-lab/signal-nfx-investor-profiles`) Actor

Export public Signal by NFX investor profiles with firms, roles, check ranges, investment focus, portfolio context, education, positions, and displayed contact links.

- **URL**: https://apify.com/automation-lab/signal-nfx-investor-profiles.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Signal NFX Investor Profiles Scraper

Build a reusable fundraising prospect list from public **Signal NFX investor profiles**.
This Actor exports investor identity, firm, role, check range, investment focus,
locations, public social/contact links, education, positions, and portfolio context.
It only returns an email when Signal explicitly displays one in public profile data;
it never guesses, derives, or purchases email addresses.

### What does this Actor do?

Signal NFX Investor Profiles Scraper accepts public Signal investor-list pages,
list slugs, and individual investor profile URLs.

It can:

- paginate a public Signal investor list;
- combine multiple stage/sector lists;
- deduplicate investors appearing in more than one input list;
- enrich list rows from each investor's public profile;
- export stable JSON, CSV, Excel, XML, or RSS through Apify datasets;
- stop precisely at your requested `maxItems` limit.

The default workflow enriches each selected investor. Turn enrichment off when you
only need list-level identity, firm, check range, and investment focus quickly.

### Who is it for

#### Startup founders

Build a stage- and sector-specific prospect list before a fundraising campaign.
Use check ranges and firm context to prioritize likely fits.

#### Fundraising consultants

Refresh reusable client prospect lists and preserve source URLs for review.

#### VC and ecosystem researchers

Compare public investor focus across stages, sectors, firms, and locations.

#### RevOps and data teams

Feed normalized investor rows into a CRM, spreadsheet, warehouse, or enrichment
pipeline without maintaining Signal pagination code.

### Why use this Signal NFX scraper?

- **List and profile inputs:** start broadly or extract one known investor.
- **Profile context:** optional social links, education, positions, and portfolio data.
- **Explicit-email policy:** an absent public email remains `null`.
- **Cross-list deduplication:** one person produces one row per run.
- **Bounded retries:** transient network errors retry; invalid inputs and stable 4xx
  responses fail clearly instead of silently returning an empty dataset.
- **No login or proxy input:** the Actor uses anonymously available public data.

### What data can I extract?

| Group | Fields |
| --- | --- |
| Identity | `investorId`, `personId`, `name`, `firstName`, `lastName`, `profileUrl`, `imageUrl` |
| Firm and role | `headline`, `roles`, `position`, `firm`, `firmId`, `firmSlug` |
| Check range | `checkMinUsd`, `checkMaxUsd`, `checkTargetUsd` |
| Investment focus | `location`, `investmentLocations`, `investmentStages`, `investmentSectors`, `investorLists` |
| Public links | `linkedinUrl`, `twitterUrl`, `facebookUrl`, `crunchbaseUrl`, `angellistUrl`, `websiteUrl` |
| Contact | `email` only when explicitly present in public Signal data |
| Background | `education`, `positions` |
| Portfolio context | `portfolio` companies, displayed total-raised values, and displayed co-investors |
| Provenance | `sourceListSlug`, `sourceListUrl`, `scrapedAt` |

Fields can be `null` or empty when a public profile does not display that information.

### Getting started

1. Open the Actor in Apify Console.
2. Add a Signal investor-list URL, a list slug, or a public investor profile URL.
3. Choose whether to include full profile details.
4. Set a small `maxItems` while testing.
5. Click **Start**.
6. Open the **Dataset** tab to preview or download results.
7. Schedule the Task if you need recurring prospect-list refreshes.

### Input parameters

#### `startUrls`

Signal list or profile URLs. Supported shapes are:

```text
https://signal.nfx.com/investor-lists/top-fintech-series-a-investors
https://signal.nfx.com/investors/brendan-wallace
```

Other hosts and unrelated Signal paths are rejected.

#### `listSlugs`

A list identifier without the `top-` and `-investors` URL wrapper.
For example, use `fintech-series-a` for the list URL above.

#### `profileUrls`

Public `/investors/{slug}` URLs for direct profile extraction.

#### `includeProfileDetails`

Defaults to `true`. When enabled, the Actor visits each selected public profile
and adds social links, roles, education, positions, and portfolio context.
Set it to `false` for a faster list-only export.

#### `maxItems`

Maximum unique investors returned across all inputs. Default: 20. Range: 1–1,000.
The Actor stops fetching and storing records when this limit is reached.

### Example: find fintech Series A investors

```json
{
  "listSlugs": ["fintech-series-a"],
  "maxItems": 10,
  "includeProfileDetails": false
}
```

This is useful for quick market mapping where list-level check and focus fields
are enough.

### Example: extract one detailed profile

```json
{
  "profileUrls": [
    "https://signal.nfx.com/investors/brendan-wallace"
  ],
  "maxItems": 1,
  "includeProfileDetails": true
}
```

### Example: recurring prospect-list refresh

```json
{
  "listSlugs": ["advertising-seed", "fintech-seed"],
  "maxItems": 50,
  "includeProfileDetails": true
}
```

Save this input as an Apify Task and schedule it. Use `personId` or `profileUrl`
as a stable key in your downstream system to compare snapshots.

### Output example

The following abbreviated record reflects the real output shape. Some long arrays
and source image URLs are omitted for readability.

```json
{
  "investorId": "5662",
  "personId": "314",
  "name": "Brendan Wallace",
  "profileUrl": "https://signal.nfx.com/investors/brendan-wallace",
  "headline": "Co-Founder / Managing Partner at Fifth Wall Ventures",
  "position": "managing_partner",
  "firm": "Fifth Wall Ventures",
  "checkMinUsd": 10000000,
  "checkMaxUsd": 25000000,
  "checkTargetUsd": 12500000,
  "investmentLocations": ["United States"],
  "linkedinUrl": "https://www.linkedin.com/in/brendanfitzgeraldwallace/",
  "email": null,
  "education": [
    {
      "degree": "MBA",
      "fieldOfStudy": "Business",
      "school": "Harvard Business School"
    }
  ],
  "sourceListSlug": "advertising-seed",
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

Public source data changes over time, so do not treat the sample values as current
investment advice.

### How much does it cost to extract Signal NFX investor profiles?

The Actor uses pay-per-event pricing:

- one small `start` charge per run;
- one `item` charge for each unique investor row stored.

Your Apify plan determines the active tier. The Console shows the exact active
price before a run starts. Profile enrichment does not create a separate charge.

At the BRONZE rate of **$0.003992 per investor** plus a **$0.005 start**, a
10-investor run costs **$0.04492**, 100 investors cost **$0.40420**, and 1,000
investors cost **$3.99700**. The live Console pricing is authoritative.

Set the record limit to enforce a predictable result count.

Apify's maximum-total-charge setting can provide an additional account-level spending guard.

### Fast list export versus profile enrichment

Use `includeProfileDetails: false` when you need:

- names and profile URLs;
- firms and roles;
- check ranges;
- list-derived stages, sectors, and locations.

Use `includeProfileDetails: true` when you also need:

- LinkedIn and other displayed public links;
- headline and person roles;
- education and work positions;
- displayed portfolio and co-investor context.

The detailed mode makes one extra public profile request per accepted investor,
so it takes longer. Both modes charge once per returned investor, not per request.

### Pagination, deduplication, and limits

Signal lists are fetched in bounded pages. The Actor follows public cursors until
`maxItems` is reached or the source reports no next page.

If one investor occurs in multiple supplied lists, the Actor stores that person
once. The first input list that yields the person is retained in `sourceListSlug`
and `sourceListUrl`; the enriched `investorLists` array can still show broader
public list membership.

### Scheduling and monitoring changes

Create an Apify Task with a fixed set of Signal lists and schedule it weekly or
monthly. Export each run's dataset to your warehouse, then compare records by
`personId`.

Useful changes to track include:

- firm or position changes;
- check-range changes;
- newly displayed social links;
- changes in stage or sector list membership;
- new public portfolio context.

This Actor returns snapshots. It does not itself send alerts or calculate diffs.

### Export to spreadsheets and data pipelines

From the Dataset tab, choose JSON, CSV, Excel, XML, or RSS. Nested arrays such as
education and portfolio are richest in JSON.

Common workflows include:

1. schedule an Apify Task;
2. send the dataset to Google Sheets, Airtable, Make, Zapier, or a webhook;
3. upsert on `personId`;
4. keep `profileUrl` and `scrapedAt` for provenance;
5. review public source links before outreach.

### Run through the Apify API with cURL

Replace `<APIFY_TOKEN>` with your token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~signal-nfx-investor-profiles/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "listSlugs": ["fintech-series-a"],
    "maxItems": 10,
    "includeProfileDetails": true
  }'
```

Poll the returned run, then read its default dataset.

### Run with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/signal-nfx-investor-profiles').call({
    listSlugs: ['fintech-series-a'],
    maxItems: 10,
    includeProfileDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/signal-nfx-investor-profiles").call(
    run_input={
        "listSlugs": ["fintech-series-a"],
        "maxItems": 10,
        "includeProfileDetails": True,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/signal-nfx-investor-profiles"
```

#### Claude Desktop, Cursor, and VS Code setup

Desktop and editor clients such as Claude Desktop, Cursor, and VS Code can use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/signal-nfx-investor-profiles"
    }
  }
}
```

Example prompts:

- “Run the Signal investor Actor for the fintech-series-a list and return 20 rows.”
- “Extract this public Signal investor profile and summarize the displayed check range.”
- “Refresh my two seed-investor lists and save the dataset URL.”

### Responsible use and legality

This Actor accesses public Signal pages and public structured responses without a
login. You are responsible for complying with Signal's terms, applicable privacy
and database laws, and rules governing your intended use.

Investor data can be incomplete, stale, or self-reported. Do not use it as the
sole basis for financial, credit, employment, or other high-impact decisions.
Do not send unlawful or deceptive outreach. Respect opt-outs and data-subject
rights. Public availability does not remove your compliance obligations.

### Limitations

- Signal controls the source structure and can change it without notice.
- Results reflect public data available at run time, not a historical archive.
- Some profiles omit checks, links, education, positions, or portfolio details.
- `email` is commonly `null`; the Actor does not infer an address.
- Profile enrichment is slower than list-only extraction.
- The Actor supports public Signal investor list and profile URLs only.
- It does not log in, reveal private introduction paths, or access Gmail data.
- `maxItems` is capped at 1,000 per run.

### Failure behavior and retries

Transient network resets, HTTP 429, and temporary server errors retry up to three
total attempts with backoff. Stable invalid URLs and permanent client errors do
not retry blindly.

The run fails with a non-zero status when:

- no supported input is supplied;
- a URL uses another host or unsupported path;
- a list or profile does not exist;
- Signal returns an unrecognized response shape after retries.

This avoids presenting an unexpected empty dataset as a successful scrape.

### Troubleshooting

#### Why did my run fail before producing records?

Check that at least one supported input field is non-empty. A list slug should look
like `advertising-seed`, not the full `top-advertising-seed-investors` wrapper.
Full URLs belong in `startUrls` or `profileUrls`.

#### Why are social links, education, and portfolio arrays empty?

Enable `includeProfileDetails`. Even then, fields remain empty when Signal does
not publicly display them.

#### Why is `email` null?

Signal did not explicitly display an email in the public profile data. This is
expected and preferable to returning a guessed or unrelated address.

#### How can I make a run faster?

Disable profile details or lower `maxItems`. Avoid supplying overlapping lists
unless cross-list deduplication is part of your workflow.

#### Can I use a proxy?

No proxy input is needed or exposed. The public source worked directly during
release validation, avoiding residential-proxy transfer and session complexity.

### Data quality tips

- Keep `profileUrl` with every CRM record for manual verification.
- Treat check ranges as public source context, not guaranteed commitments.
- Prefer `personId` for deduplication within Signal.
- Preserve `scrapedAt` when comparing scheduled snapshots.
- Review displayed links before initiating contact.
- Start with 10–25 items before increasing a recurring Task.

### Related Automation Lab Actors

Signal-specific output is intentionally standalone. For adjacent public profile
and contact workflows, see:

- [LinkedIn Public People Profile Scraper](https://apify.com/automation-lab/linkedin-public-people-profile-scraper)
- [Website Email Extractor](https://apify.com/automation-lab/website-email-extractor)
- [Bulk Email Address Verifier](https://apify.com/automation-lab/bulk-email-address-verifier)

Those Actors have different sources and contracts. They are not automatic
fallbacks or included enrichment steps in this Actor.

### FAQ

#### Does the Actor scrape every Signal investor?

It paginates the specific public lists you provide, up to `maxItems`. It does not
claim to enumerate private profiles or all possible Signal records.

#### Does it return investor emails?

Only when an email is explicitly exposed in the public Signal profile data.
No inferred, pattern-generated, brokered, or private email is returned.

#### Can I combine several lists?

Yes. Add multiple slugs or URLs. Duplicate people are returned once.

#### Can I extract only one investor?

Yes. Supply a public profile URL in `profileUrls` or `startUrls`.

#### Are portfolio companies complete?

No. The `portfolio` field reflects the bounded public investment context displayed
on the Signal profile and should not be treated as a complete investment history.

#### Is enrichment charged separately?

No. Only the start and returned-item events are configured. Enrichment requests
do not create an additional customer charge.

#### Can I schedule recurring runs?

Yes. Save the input as an Apify Task and use the platform scheduler. Compare the
resulting datasets in your own workflow.

#### Where are the results stored?

Each run writes normalized investor records to its default Apify dataset. Use the
Dataset tab or API to preview and export them.

# Actor input Schema

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

Public Signal URLs such as an investor list or an individual /investors/{slug} profile.

## `listSlugs` (type: `array`):

Signal list identifiers without the top- and -investors URL wrapper, for example advertising-seed or fintech-series-a.

## `profileUrls` (type: `array`):

Optional public Signal investor profile URLs to extract directly.

## `includeProfileDetails` (type: `boolean`):

Visit each public profile to add social links, roles, education, positions, portfolio context, and any explicitly displayed email.

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

Stop after this many unique investor records across all supplied lists and profiles.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://signal.nfx.com/investor-lists/top-advertising-seed-investors"
    }
  ],
  "listSlugs": [],
  "profileUrls": [],
  "includeProfileDetails": true,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing the extracted investor profiles.

# 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 = {
    "startUrls": [
        {
            "url": "https://signal.nfx.com/investor-lists/top-advertising-seed-investors"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/signal-nfx-investor-profiles").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 = { "startUrls": [{ "url": "https://signal.nfx.com/investor-lists/top-advertising-seed-investors" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/signal-nfx-investor-profiles").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 '{
  "startUrls": [
    {
      "url": "https://signal.nfx.com/investor-lists/top-advertising-seed-investors"
    }
  ]
}' |
apify call automation-lab/signal-nfx-investor-profiles --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/signal-nfx-investor-profiles"
        }
    }
}

```

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/kPxaA87aLTRkihg6r/builds/svvUoqS5It3ICswiH/openapi.json