Discover/NFX API
live

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.

Endpoint health
verified 2d ago
get_investor_list
search_investors_by_firm
get_firm_profile
get_investor_profile
get_firm_investor_investments
6/6 passing latest checkself-healing
Endpoints
6
Updated
9d ago

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.

This call costs1 credit / call— charged only on success
Try it
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').
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.
Number of investors per page. Clamped to 1-100.
api.parse.bot/scraper/0173ac51-c94d-4f1a-8563-d0f3eefc0918/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
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'
Python SDK · recommended

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")
All endpoints · 6 totalmissing one? ·

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).

Input
ParamTypeDescription
slugrequiredstringInvestor list slug identifying the vertical and stage combination (e.g. 'ai-seed', 'fintech-series-a', 'advertising-seed', 'enterprise-series-b', 'los-angeles-southern-california').
afterstringPagination 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.
limitintegerNumber of investors per page. Clamped to 1-100.
Response
{
  "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.

Reliability & maintenanceVerified

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.

Last verified
2d ago
Latest check
6/6 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • 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
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 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.

Frequently asked questions
Does NFX Signal have an official developer API?+
NFX does not publish a public developer API for Signal data. The NFX Signal site at signal.nfx.com is intended for browsing investors manually. This Parse API provides programmatic access to the same investor list and profile data.
What does get_investor_list actually return for each investor?+
Each investor object in the 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?+
Not currently as a single aggregated firm portfolio. The 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?+
Contact emails and phone numbers are not present in any endpoint response. 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?+
The 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.
Page content last updated . Spec covers 6 endpoints from signal.nfx.com.
Related APIs in FinanceSee all →
signalfire.com API
Access detailed information about SignalFire's venture capital operations, including their investment team members, portfolio companies, and industry sectors they focus on. Use this data to research their investment strategy, identify key decision-makers, and understand their portfolio composition.
openvc.app API
Search through 16,000+ venture capital firms and angel investors on OpenVC. Filter by industry category (e.g., Energy, Fintech) to discover investors focused on a specific sector, then retrieve detailed profiles including firm type, investment thesis, check size, geographic focus, and portfolio companies.
mercury.com API
Search and filter 295+ startup investors by investment preferences, check sizes, industries, and stages to find the right funding match for your company. Access detailed contact information and investment criteria for VCs, angels, and seed funds to streamline your fundraising outreach.
vcsheet.com API
Access investor profiles, venture funds, curated sheets, and press contacts from VCSheet.com. Supports listing, searching, and detailed profile lookups.
cbinsights.com API
Access CB Insights data including company and investor profiles, funding history, competitor maps, the unicorn list, and research reports.
signalstart.com API
Browse and search forex signals from SignalStart.com to access performance metrics, trade history, and historical growth charts. Compare signal details to make informed trading decisions based on real performance data.
ticker.finology.in API
Search and analyze stocks, view company financials and market indices, track super investors and their holdings, and explore IPO listings and sector performance. Get comprehensive market data including company overviews, financial statements, and real-time dashboard information to make informed investment decisions.
seedtable.com API
Access detailed company intelligence including funding history, investor information, executive profiles, acquisition data, competitors, and industry events all from a single source. Get comprehensive insights about any company to inform your investment decisions, competitive analysis, or business research.