How to Add Real-Time Funding Signals to Your Clay and Apollo Stack

TL;DR: Add funding signals to Clay by calling a funding-data API from an HTTP API column on a schedule, so companies that just raised land in your table and flow into Apollo to sequence. Clay has no native Fundable tile, but the HTTP API column calls Fundable's /companies endpoint directly, and running it on your cadence keeps the list fresher than Clay's native sources refresh on their own.

If you run outbound in Clay and Apollo, you already know who to reach and how, but not when. A funding signal is the "when." What follows is how to pull that signal into Clay with an HTTP API column, using Fundable, a real-time VC funding and startup data platform, as the source.

What is Clay data enrichment

Clay data enrichment adds external data to the rows in a Clay table, drawing from 150+ connected sources. When a source has no native tile, Clay's HTTP API column calls its REST API directly, which is how any funding API reaches a Clay table.

Why funding signals belong in your stack

A recent-round signal turns a static account list into a triggered one. A company enters your sequence because it just raised, not because it happened to sit on a list, so the outreach lands while the budget is new and the priorities are still forming.

Ways to get funding data into Clay

• A manual CSV import: drop in a list, such as a bulk export from Fundable, though it goes stale after you upload it.
• An HTTP API column calling the Fundable API live: stays current on a schedule (the walkthrough below). See how to track newly funded startups with an API and how to give Claude and ChatGPT live funding data.

What you need

• A Clay account with HTTP API columns.
• A Fundable API key, stored as a Bearer token. The API is self-serve and pay-as-you-go, with 200 free credits to start.
• Apollo connected to Clay.

Add funding signals in four steps

1. Store your key. Save your Fundable API key in Clay's Secrets Manager and reference it in the header, so it is not pasted into every column.

2. Add an HTTP API column on /companies. Point it at POST /companies with a latest_deal date filter, your round types, and your ICP by industry and location. Set date_start to your lookback window.

POST https://www.tryfundable.ai/api/v1/companies
Authorization: Bearer {{secrets.fundable_key}}
Content-Type: application/json

{
  "company": {
    "industries": ["artificial-intelligence"],
    "locations": ["san-francisco-california"]
  },
  "latest_deal": {
    "financing_types": [{ "type": "SEED" }, { "type": "SERIES_A" }],
    "date_start": "2026-08-25"
  },
  "sort_by": "most_recent_raise",
  "page_size": 100
}

3. Map the response. Use dot notation to pull the fields you want into columns: data.companies[].name, .domain, .total_raised, .num_investors, and the latest round.

4. Filter and push to Apollo. Filter the table to companies whose latest round falls inside your window, then push those rows into Apollo to sequence. Run the column on a schedule to keep it current.

Outcome: the table flags who just raised, refreshed on your cadence, and only the recent raisers flow into an Apollo sequence.

Two things to know. date_start filters on the round's announced date, not on when Fundable added the record; for a strict feed of only what is new since your last run, Fundable's Funding Alerts API tracks matches server-side on Pro+. And each returned company costs one credit, so scope the filter to your ICP.

Enrich beyond the round

The same HTTP API column pattern works across Fundable's other endpoints, so a Clay table can carry more than the latest raise:

• The investors on a company's latest round, via the company endpoint.
• Full funding history, every prior round rather than only the latest, via /company/deals.
• Investor and fund profiles, a firm's portfolio and activity, via /investors.
• Founders and partners, the people behind a company or a fund, via /people.

Point a column at the endpoint you need and map its fields the same way.

How Fundable, Clay, and Apollo fit together

Each tool owns one layer of a signal-based outbound stack. Fundable is the timing layer, the companies that just raised. Apollo is the contact layer, the person to reach and the channel. Clay is where they meet: it pulls the funding signal, filters, and pushes the list to Apollo, while your sequencer runs the outreach. Use this setup when you already run Clay and Apollo and want a funding trigger inside them, not a separate tool.

Add the funding layer to your stack

Connect Fundable to Clay and let the companies that just raised flow into Apollo on their own.

Get your API key · Book a demo