NFX APIsignal.nfx.com ↗
Access ranked investor lists, firm profiles, and investment records from NFX Signal by vertical and stage. 6 endpoints covering seed through Series B and beyond.
What is the NFX API?
The NFX Signal API exposes 6 endpoints for querying ranked investor lists, firm profiles, and individual investor data from signal.nfx.com. The get_investor_list endpoint returns paginated investor profiles filtered by industry vertical (e.g. AI, FinTech) and funding stage (e.g. seed, series_a), each profile including firm name, position, investment range, and geographic locations. Firm-level endpoints return founding year, fund description, social links, and attributed investment records per partner.
curl -X GET 'https://api.parse.bot/scraper/0173ac51-c94d-4f1a-8563-d0f3eefc0918/get_investor_list?slug=ai-seed' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace signal-nfx-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: NFX Signal Investors API — discover investors, firms, and portfolios."""
from parse_apis.signal_nfx_com_api import SignalNfx, InputNotFound
client = SignalNfx()
# Browse the AI seed investor list, capping total items fetched.
for investor in client.investors.list(slug="ai-seed", limit=5):
print(
f"{investor.name} ({investor.firm_name}) "
f"— range ${investor.min_investment:,}–${investor.max_investment:,}"
)
for membership in investor.investor_lists[:3]:
print(f" list: {membership.slug} ({membership.vertical} {membership.stage})")
# Drill into the first investor's full profile.
top = client.investors.list(slug="ai-seed", limit=1).first()
if top is not None:
profile = top.details()
print(f"\nProfile: {profile.name} — {profile.headline}")
print(f" Roles: {', '.join(profile.roles)}")
print(f" Fund size: {profile.current_fund_size}")
for inv in profile.investments_on_record[:3]:
print(f" Investment: {inv.company_name} (raised {inv.total_raised})")
# Navigate to the investor's firm and get the full firm profile.
try:
firm = client.firms.get(firm=top.firm_slug)
except InputNotFound:
print("Firm not found")
raise
firm_detail = firm.profile()
print(f"\nFirm: {firm_detail.firm_name} (founded {firm_detail.founding_year})")
print(f" Locations: {', '.join(firm_detail.locations)}")
print(f" Fund size: {firm_detail.current_fund_size}")
print(f" Co-invested firms: {len(firm_detail.coinvested_firms)}")
# List investment portfolios for each investor at the firm.
for portfolio in firm.investments(limit=3):
print(
f" {portfolio.name} ({portfolio.position}) "
f"— {portfolio.investments_on_record_count} investments on record"
)
# Retrieve all firm investments with full investor bios.
for record in firm.all_investments(limit=3):
print(
f" {record.investor.name}: "
f"{record.investments_count} investments"
)
print("\nexercised: investors.list / details / firms.get / profile / investments / all_investments")
Retrieve a ranked list of investors from NFX Signal filtered by industry vertical and funding stage. Each list is identified by a slug combining the vertical name and stage (e.g. 'ai-seed', 'fintech-series-a', 'enterprise-series-b'). Returns investor profiles with firm, position, investment range, locations, and cross-references to other lists. Supports cursor-based pagination; pass the returned end_cursor as the 'after' parameter to fetch the next page. Each page returns up to 'limit' investors (default 20, max 100).
| Param | Type | Description |
|---|---|---|
| slugrequired | string | Investor list slug identifying the vertical and stage combination (e.g. 'ai-seed', 'fintech-series-a', 'advertising-seed', 'enterprise-series-b', 'los-angeles-southern-california'). |
| after | string | Pagination cursor. Pass the 'end_cursor' value from a previous response's pagination object to retrieve the next page of results. Omit for the first page. |
| limit | integer | Number of investors per page. Clamped to 1-100. |
{
"type": "object",
"fields": {
"stage": "string — funding stage (e.g. 'seed', 'series_a', 'series_b')",
"list_id": "string — internal list ID",
"location": "string or null — geographic filter applied to this list",
"vertical": "string — industry vertical name (e.g. 'AI', 'FinTech')",
"investors": "array of investor profile objects with name, firm, position, investment range, locations, and list memberships",
"list_slug": "string — the slug identifying this investor list",
"pagination": "object with has_next_page (boolean), end_cursor (string), and record_count (integer)",
"investor_count": "integer — total number of investors in this list"
},
"sample": {
"data": {
"stage": "seed",
"list_id": "3",
"location": null,
"vertical": "AI",
"investors": [
{
"name": "Marc Andreessen",
"slug": "marc-andreessen",
"position": "general_partner",
"firm_name": "Andreessen Horowitz",
"firm_slug": "andreessen-horowitz",
"last_name": "Andreessen",
"person_id": "3",
"first_name": "Marc",
"investor_lists": [
{
"slug": "ai-series-b",
"stage": "Series B",
"vertical": "AI"
},
{
"slug": "biotech-series-b",
"stage": "Series B",
"vertical": "BioTech"
},
{
"slug": "education-series-b",
"stage": "Series B",
"vertical": "Education"
}
],
"max_investment": "40000000",
"min_investment": "500000",
"target_investment": "20000000",
"investor_profile_id": "5350",
"investment_locations": [
"Mountain View, California",
"Menlo Park, California"
]
}
],
"list_slug": "ai-seed",
"pagination": {
"end_cursor": "MjA",
"record_count": 5396,
"has_next_page": true
},
"investor_count": 5396
},
"status": "success"
}
}About the NFX API
Investor Lists by Vertical and Stage
The get_investor_list endpoint takes a slug parameter that combines a vertical name and stage — for example ai-seed, fintech-series-a, or enterprise-series-b. Each response includes the vertical, stage, investor_count, and a paginated investors array. Each investor object carries name, firm, position, investment_range, locations, and list_memberships. Pagination is cursor-based: pass the end_cursor from the pagination object as the after parameter to fetch the next page, with limit clamped between 1 and 100.
Firm and Investor Profiles
get_firm_profile accepts a slug such as sequoia-capital or andreessen-horowitz and returns the full firm record: firm_name, description, founding_year, locations, website_url, twitter_url, linkedin_url, angellist_url, and the full roster of investors at that firm with their positions and investment details. get_investor_profile takes a person slug (e.g. marc-andreessen) and returns roles, degrees, headline, location, position, firm_name, and firm_slug.
Investment Records per Firm
Two endpoints handle investment-level data. get_firm_investor_investments returns personally attributed investments for every investor at a given firm, with each investor's investments_on_record_count and an investments array of company-level records. get_all_firm_investments performs a full fan-out and returns up to 1,000 investment records per investor, aggregated under investments_by_investor, plus firm-level social URLs and a total_investment_count across all partners. Both endpoints accept a firm_slug with automatic normalization of spaces to hyphens.
Searching by Firm
search_investors_by_firm looks up investors at a specific firm using a URL-friendly firm slug. It returns firm_name, firm_description, founding_year, firm_locations, and an investors array. Slugs are auto-normalized, so Sequoia Capital and sequoia-capital both resolve correctly. Firm and person slugs are surfaced in list and search responses, making them discoverable without prior knowledge.
The NFX API is a managed, monitored endpoint for signal.nfx.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when signal.nfx.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official signal.nfx.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a targeted investor outreach list filtered by vertical (e.g. 'fintech') and stage (e.g. 'series_a') using get_investor_list
- Map every partner at a given VC firm and their individual investment records using get_all_firm_investments
- Enrich a CRM with firm descriptions, founding years, and social URLs from get_firm_profile
- Identify investor roles (VC, Angel, Scout, Founder) and educational background via get_investor_profile
- Compare investment activity volume across firms by aggregating total_investment_count from get_all_firm_investments
- Discover which investor lists a specific person or firm appears in via the list_memberships field on investor objects
- Automate fundraising research by paginating through full verticals using cursor-based pagination on get_investor_list
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does NFX Signal have an official developer API?+
What does get_investor_list actually return for each investor?+
investors array includes the investor's name, firm, position (e.g. general_partner), investment range, geographic locations, and any Signal list memberships. The response also includes the vertical, stage, investor_count, and a pagination object with has_next_page, end_cursor, and record_count for cursor-based iteration.Does the API return portfolio company data at the firm level, not just per-investor?+
get_all_firm_investments and get_firm_investor_investments endpoints return investment records broken out per individual investor under investments_by_investor, along with a total_investment_count. A consolidated firm-level portfolio view isn't a separate endpoint. You can fork this API on Parse and revise it to add that aggregation endpoint.Are there any gaps in investor profile data — for example, contact emails or phone numbers?+
get_investor_profile returns headline, location, roles, degrees, position, firm_name, and firm/person slugs, but no direct contact information. NFX Signal does not surface contact details publicly. You can fork this API on Parse and revise it if Signal adds that data in the future.How do I paginate through a full investor list for a given vertical and stage?+
get_investor_list endpoint returns a pagination object containing has_next_page (boolean) and end_cursor (string). Pass the end_cursor value as the after parameter on your next request with the same slug. Continue until has_next_page is false. The limit parameter controls page size and is clamped to a maximum of 100.