# Full ICP Search — Clay Alternative for Companies, Leads & Jobs (`b2bsearch/full-icp-search`) Actor

Find companies, decision makers with live emails and open jobs matching an ideal customer, candidate or investor profile. Filter by industry, size, funding, hiring, title, seniority, location, experience. Free preview counts. Clay alternative, no login. Leads from $1.50/1k.

- **URL**: https://apify.com/b2bsearch/full-icp-search.md
- **Developed by:** [B2B Search Enriched](https://apify.com/b2bsearch) (community)
- **Categories:** Lead generation, AI, Automation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 person delivered with an emails

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

## Full ICP Search — Clay Alternative for Companies, Leads & Jobs

Describe your **ideal customer profile** in plain English to Claude or any
MCP client, and get back the **companies** that fit it, the **decision
makers** inside them with an email that reaches them today, and the **open
jobs** they post — in one run, one dataset, priced per row. The same Actor
finds an **ideal candidate profile** (people by title, skills, experience,
past employers), and partners or **investors** (VC partners, angels, funds).
No Clay subscription, no credits to buy, no login, no cookies.

- **Companies, people and jobs in one search.** Pick what to find:
  companies and the people in them, companies only, or people only.
- **A profile is many signals at once.** Industry, headcount, HQ country
  and city, founding year, last funding round and its date, words in the
  company description, job titles the company is hiring for, words in its
  job postings; for people: level, title, headline keywords, country, city,
  years of experience, past companies, past titles, when they started the
  current job, languages.
- **Built for AI agents.** A free preview counts companies, people and job
  postings before anything is bought, so Claude can tune the profile in a
  few calls and buy only the rows it keeps.
- **Every entity is priced on its own.** A company, a lead with a live
  email, a person without contact details, a job posting, a mobile number.
  Rows that find nothing are free.

### Use it with Claude (MCP)

The fastest way to use this Actor is to let an AI agent fill the filters.
Connect Apify MCP to Claude (Claude Desktop, Claude Code, Cursor or any MCP
client):

```
https://mcp.apify.com?tools=b2bsearch/full-icp-search
```

Then describe who you want, in English, the way you would brief a
researcher:

> Find 50 US B2B SaaS companies with 51–500 employees that raised a Series A
> or B since January 2025 and are hiring SDRs. For each, give me the VP of
> Sales or CRO with a work email. Preview the counts first.

> I'm hiring a senior backend engineer: people in Germany or the Netherlands
> with "golang" or "kubernetes" in their headline, at least 6 years of
> experience, who used to work at delivery or fintech startups.

> Find partners at venture capital firms in London who write about climate
> or energy, with an email.

The agent turns the brief into this Actor's input, runs `previewOnly: true`
to see how many companies, people and jobs match, narrows or widens, and
only then runs the paid search. Each run's input, counts and rows come back
to the agent, so it can compare segments, drop the weak one and pull the
next — the loop that takes an afternoon of clicking in a table tool.

#### What does ICP mean here?

**ICP = ideal customer, candidate or company profile**: the description of
who you are looking for. For a sales team it is the accounts and buyers
you sell to; for a recruiter it is the candidate; for a founder it can be
the partner, agency or investor to reach. This Actor reads all three from
the same filters.

### Use cases at a glance

| You want | Fields that do it |
|---|---|
| Decision makers at companies that fit your ICP | `companyCountries`, `industries`, `companySizeMin`/`Max`, `seniority` |
| Companies building a team you sell to (hiring SDRs, data engineers) | `hiringJobTitles`, `jobsPerCompany` |
| Companies that use a tool, read from their job postings | `hiringJobKeywords: ["snowflake"]` |
| Founders of startups that just raised and are hiring their first sellers | `fundingStages`, `fundedAfter`, `hiringJobTitles` |
| Leaders in their first months in the seat, when budgets move | `startedCurrentRoleAfter`, `jobTitles`, `seniority` |
| Your champions who left a customer for a new company | `pastCompanyDomains`, `startedCurrentRoleAfter` |
| The buying committee of your target accounts | `companyDomains`, `seniority`, `peoplePerCompany` |
| Candidates by skills, experience and past employers | `find: "people"`, `keywords`, `yearsExperienceMin`, `pastCompanyDomains` |
| Candidates open to a new role | `find: "people"`, `betweenJobs: true` |
| Funds that invest in a theme, and their partners | `industries: ["Venture Capital and Private Equity Principals"]`, `companyKeywords`, `jobTitles: ["partner"]` |
| Only new accounts every week | `excludeDatasets` on a schedule |

### What can you find?

#### How do I find decision makers at companies that match my ICP?

`find: "companies_and_people"` (the default). Describe the companies, then
the people:

```json
{
  "companyCountries": ["us"],
  "industries": ["Software Development"],
  "companySizeMin": 51,
  "companySizeMax": 200,
  "seniority": ["founder", "cxo", "vp"],
  "maxCompanies": 100,
  "peoplePerCompany": 2
}
```

Each company row is followed by its people, most senior first. With no
levels and no titles you get the leadership (founders, C-level, VPs,
directors). Companies where nobody matches are skipped free.

#### How do I find companies that are hiring for a role?

A company hiring SDRs is building a sales team; one hiring a data engineer
is buying data tools. Add `hiringJobTitles` (and optionally
`hiringJobKeywords`, words in the posting text) and `jobsPerCompany` to see
the postings:

```json
{
  "companyCountries": ["us"],
  "industries": ["Software Development"],
  "companySizeMin": 51,
  "companySizeMax": 500,
  "hiringJobTitles": ["sales development representative", "sdr"],
  "hiringPostedWithin": "month",
  "jobTitles": ["sales", "revenue"],
  "seniority": ["vp", "cxo", "director"],
  "peoplePerCompany": 2,
  "jobsPerCompany": 2
}
```

Every company row then carries its hiring signal: open jobs, postings in
the last 30 days, the titles the search matched. Staffing agencies and job
boards are left out.

#### How do I find leads at recently funded startups?

Funding rounds and dates are company filters:

```json
{
  "find": "people",
  "companyCountries": ["us"],
  "industries": ["Financial Services"],
  "fundingStages": ["series_a"],
  "fundedAfter": "2025-01-01",
  "seniority": ["founder", "cxo"],
  "peoplePerCompany": 1,
  "maxPeople": 200
}
```

With `find: "people"` only the people are delivered (and charged), one per
company here.

#### How do I find founders of funded startups that are hiring their first sellers?

Funding and hiring filters combine. A seed or Series A company that posts
account executive jobs is building its first sales team:

```json
{
  "companyCountries": ["us"],
  "companySizeMax": 200,
  "fundingStages": ["seed", "series_a"],
  "fundedAfter": "2024-06-01",
  "hiringJobTitles": ["account executive"],
  "hiringPostedWithin": "3months",
  "seniority": ["founder", "cxo"],
  "peoplePerCompany": 1,
  "jobsPerCompany": 1
}
```

Each company row comes with its founder or CEO and one of the postings.
Keep the size cap: funding records of large, older companies are often
missing or out of date.

#### How do I find leaders who just started a new job?

A new VP of Marketing reviews tools and agencies in the first months.
`startedCurrentRoleAfter` keeps people who started their current job on or
after a date:

```json
{
  "companyCountries": ["us"],
  "industries": ["Software Development"],
  "companySizeMin": 51,
  "companySizeMax": 500,
  "jobTitles": ["marketing"],
  "seniority": ["vp", "cxo"],
  "startedCurrentRoleAfter": "2025-09-01",
  "peoplePerCompany": 1
}
```

#### How do I find my champions who moved to a new company?

People who used to work at your customers and have just started somewhere
else already know your product. Name the customers' domains in
`pastCompanyDomains` and add a country (a people search has to start from a
country, a title, a headline word or a company domain):

```json
{
  "find": "people",
  "pastCompanyDomains": ["stripe.com", "notion.so", "figma.com"],
  "personCountries": ["us"],
  "startedCurrentRoleAfter": "2025-09-01",
  "seniority": ["cxo", "vp", "director"],
  "maxPeople": 50
}
```

Each row shows the person's new title and company.

#### How do I find companies that use a tool, from their job postings?

Job postings name the stack: a company hiring data engineers who know
Snowflake runs Snowflake. `hiringJobKeywords` reads the posting text;
pair it with a title and a country so the text search stays small:

```json
{
  "companyCountries": ["gb"],
  "hiringJobTitles": ["data engineer"],
  "hiringJobKeywords": ["snowflake"],
  "jobTitles": ["data", "engineering"],
  "seniority": ["cxo", "vp", "director"],
  "peoplePerCompany": 1,
  "jobsPerCompany": 1
}
```

Every company row lists the matching job titles; the job row links a
posting that names the tool.

#### How do I find candidates by skills, experience and past employers?

`find: "people"` with person filters. Contact details are optional: switch
`requireEmail` off to get profiles at the lower person price.

```json
{
  "find": "people",
  "jobTitles": ["backend engineer", "software engineer"],
  "keywords": ["golang", "kubernetes"],
  "personCountries": ["de", "nl"],
  "yearsExperienceMin": 6,
  "requireEmail": false,
  "maxPeople": 100
}
```

`pastCompanyDomains` finds alumni of the companies you name (people who
have left them), `pastJobTitles` people who held a title before,
`betweenJobs: true` only people without a current position (reached at a
personal address; the row shows their last job), and
`startedCurrentRoleAfter` people who just changed jobs.

#### How do I find investors, VC partners and funds?

Investors are people at investment firms. The firms are an industry:

```json
{
  "find": "people",
  "industries": ["Venture Capital and Private Equity Principals"],
  "jobTitles": ["partner", "principal"],
  "personCountries": ["gb"],
  "keywords": ["climate", "energy"],
  "maxPeople": 50
}
```

For funds that invest in a theme, describe the funds and ask for their
partners: the default `find` with the same industry, `companyKeywords: ["climate"]` and `jobTitles: ["partner"]` returns each fund with a partner
under it. For the funds alone, use `find: "companies"`. Angel investors
usually say so in their headline: `keywords: ["angel investor"]`.

#### How do I find contacts for my own account list (ABM)?

Paste up to 1,000 website domains into `companyDomains`. Each domain is one
account: the company page that owns the domain, not the pages of resellers
or of sites hosted on it. Domains that match no company are listed in a
free note row.

```json
{
  "companyDomains": ["stripe.com", "linear.app", "vercel.com"],
  "seniority": ["cxo", "vp"],
  "peoplePerCompany": 2
}
```

#### How do I find companies by what they do?

`companyKeywords` keeps companies whose description, name or industry
mentions any of the words (`shopify`, `cybersecurity`, `b2b saas`). The
words are read on each company, so pair them with an industry, a country
and a size; on their own the run reads many companies to find a few.

### How it works

1. **Companies.** The company profile picks the accounts: the company
   database for firmographic filters, or the employers behind matching job
   postings when a hiring filter is set. Largest companies, or those with
   the most matching postings, come first.
2. **People.** For each company, its people at the chosen levels and
   titles from the company roster, most senior first; with person filters
   a roster cannot answer (headline, city, past employers, experience,
   languages, start date), the people search runs over a batch of
   companies at once. Assistants and chiefs of staff, filed under the
   leadership levels in the data, are left out unless you ask for them.
3. **Contacts.** With `requireEmail` on (the default), each person needs a
   work address on the current company's domain or a personal one.
   Addresses at earlier employers never count. People without one are
   skipped free.
4. **Jobs.** With `jobsPerCompany`, each company's open postings.

`find: "people"` without company-only filters skips step 1 and searches
people directly, with the company filters applied to their current
employer. When the company filters are all there is (country, industry,
size), the run walks those companies and delivers their people.

### Input

| Field | What it does |
|---|---|
| `find` | `companies_and_people` (default), `companies` or `people`. |
| `previewOnly` | Free counts of companies, people and job postings; no rows, no charge. |
| `maxCompanies` | Companies to deliver (default 25). |
| `peoplePerCompany` | People per company (default 3). |
| `jobsPerCompany` | Open job postings per company (default 0). |
| `maxPeople` | People across the run. Default `maxCompanies × peoplePerCompany`, or 100 for `find: "people"`. |
| `requireEmail` | On: only people with a live email, charged as leads. Off: profiles without contacts at the person price. |
| `emailType` | `any`, `work` (current company only) or `personal`. |
| `includePhones` | Verified mobile numbers on lead rows, charged per lead that has one. |
| `companyCountries`, `industries`, `companySizeMin`, `companySizeMax` | The firmographic core. |
| `companyKeywords` | Words in the company description. |
| `hiringJobTitles`, `hiringJobKeywords`, `hiringPostedWithin` | Companies with matching job postings in the last week, month or three months. |
| `fundingStages`, `fundedAfter` | Last funding round and its date. |
| `foundedAfterYear`, `foundedBeforeYear`, `hqCities` | Age and headquarters. |
| `companyDomains`, `excludeCompanyDomains` | Your account list; your customers or competitors to leave out. |
| `seniority`, `jobTitles`, `excludeJobTitles` | Level and current title of the people. |
| `keywords` | Words in the person's headline: skills, specialties, "angel investor". |
| `personCountries`, `personCities` | Where the people live. |
| `pastCompanyDomains`, `pastJobTitles` | Alumni of companies; people who held a title before. |
| `yearsExperienceMin`, `yearsExperienceMax` | Years since the first job on the profile. |
| `startedCurrentRoleAfter` | New in their role since a date. |
| `languages`, `betweenJobs` | Profile languages; only people without a current job. |
| `keepCompaniesWithoutPeople` | Also deliver companies where nobody matched (charged as companies). |
| `excludeDatasets` | Earlier runs' datasets: their companies and people are skipped free. |

A run that cannot work says so before anything is charged: a hiring filter
without a country, a people search with nothing that says who, a typo in a
funding stage.

### Output

One dataset; `_type` says what each row is.

| `_type` | Columns |
|---|---|
| `company` | `companyName`, `companyDomain`, `companyWebsite`, `companyLinkedinUrl`, `companyIndustry`, `companySize`, `companyCountry`, `companyCity`, `companyFounded`, `companyDescription`, `fundingStage`, `lastFundingDate`, `lastFundingAmountUsd`, hiring: `openJobs`, `jobsLast30Days`, `matchingJobs`, `matchingJobTitles`, `topJobTitles30d`; `peopleFound` |
| `person` | `fullName`, `firstName`, `lastName`, `jobTitle`, `seniority`, `headline`, `email`, `emailType`, `workEmail`, `personalEmail`, `linkedinUrl`, `twitterUrl`, `githubUrl`, `facebookUrl`, `location`, `countryCode`, `phoneOnRecord`, `phone`, the company columns of their employer, `personId` |
| `job` | `jobTitle`, `jobUrl`, `jobPostedAt`, `jobLocation`, `jobCountry`, `jobSeniority`, `employmentType`, `applicantRange`, `companyName`, `jobsDataAsOf` |

Rows with another `_status` are free notes: the preview counts, how many
companies had nobody matching, how many people had no live email, which
domains matched no company.

The dataset has five views: **Everything**, **Companies**, **People**,
**Emails for outreach tools** (name, email, title, company domain, the
columns Instantly, Lemlist, Smartlead and HubSpot import) and **Jobs**. A
view picks columns, not rows: each one starts with `_type`, so filter on
it (`person` for an outreach import) in the export or the spreadsheet.
Company and job rows, and the people found through a company, carry
`companyId`, so they join in a spreadsheet.

### Pricing

Pay per entity delivered, priced by your Apify plan, plus the platform's
small start fee per run:

| Event | Free plan | Starter | Scale | Business and up |
|---|---|---|---|---|
| `company-found` — a company row | $2.00 / 1,000 | $2.00 / 1,000 | $1.75 / 1,000 | $1.50 / 1,000 |
| `lead-found` — a person with a live email | $3.00 / 1,000 | $2.50 / 1,000 | $2.00 / 1,000 | $1.50 / 1,000 |
| `person-found` — a person without contact details | $1.00 / 1,000 | $1.00 / 1,000 | $0.90 / 1,000 | $0.80 / 1,000 |
| `job-found` — a job posting | $1.60 / 1,000 | $1.60 / 1,000 | $1.40 / 1,000 | $1.20 / 1,000 |
| `phone-found` — a mobile number on a lead | $5.00 / 1,000 | $4.00 / 1,000 | $3.50 / 1,000 | $3.00 / 1,000 |

Free: the preview counts, companies skipped because nobody matched, people
without a live email, repeats, people and companies from your excluded
datasets, and every note row.

Example: 100 companies with 2 leads each and 2 job postings each costs, on
Starter, 100 × $0.002 + 200 × $0.0025 + 200 × $0.0016 = **$1.02**.

The Store page's "from" price quotes the cheapest plan tier.

#### How does this compare with Clay?

Clay is a spreadsheet that calls data providers for you, sold as a monthly
plan with actions and data credits; its pricing page (checked 31 October
2026\) gives the free plan 100 data credits a month and prices data credits
from $0.05 each. This Actor is the list-building half of that workflow as
one search: no plan, no credits, no table to build. A lead with a live
email costs $0.0015–$0.003 depending on your Apify plan, a company row
$0.0015–$0.002, and the preview that sizes a profile is free.

Clay does far more than list building (custom columns, AI writing, CRM
sync). If what you use it for is "find the accounts, find the people, get
the emails", this is that, priced per row and callable from Claude. To
enrich a CSV you already have, use *Waterfall Lead Enrichment* in this
family.

### Measured runs

On the live database, 31 October 2026:

| Run | Rows | Time |
|---|---|---|
| Free preview, US software companies 51–200 + their leadership | 3 counts | 6 s |
| 5 US software companies 51–200, 2 leaders each with email | 5 companies, 9 leads | 8 s |
| 5 US software companies hiring SDRs, sales leaders, 2 jobs each | 5 companies, 7 leads, 10 jobs | 10 s |
| 6 founders and CEOs of US fintechs with a Series A since 2025 | 6 leads | 8 s |
| 6 backend engineers in Germany, 5+ years, profiles only | 6 people | 4 s |
| 3 account domains, C-level and VPs with email | 3 companies, 5 leads | 4 s |
| 5 US seed and Series A startups hiring account executives, founder and one posting each | 5 companies, 5 leads, 5 jobs | 8 s |
| 5 US software companies, a marketing VP or CMO in the seat since September 2025 | 5 companies, 5 leads | 13 s |
| 5 former Stripe, Notion or Figma people now leading elsewhere in the US | 5 leads | 6 s |
| 5 product people in the UK between jobs, personal email | 5 leads | 3 s |

Runs with person filters a company roster cannot answer (city, headline,
past employers) search people over batches of companies and take longer:
4 companies with marketing leaders living in New York took 16 s.

### Honest limits

- **Not every company has people on record at every level.** Small
  companies often have only founders; the run note says how many companies
  were skipped.
- **Emails are on record, not verified at run time.** Run your usual
  verifier before a large send. Addresses are never guessed from a pattern.
- **Job postings follow the jobs data's own date** (`jobsDataAsOf` on every
  job row), which can be several days behind today.
- **Funding is the last recorded round**, one per company: `seed` means
  "has not raised past seed yet". Records of large and older companies are
  often missing or out of date, so pair an early stage with a size cap.
- **`seniority` is filled on rows from a company roster.** People found
  through the people search (headline, city, past employers, experience)
  carry their title only.
- **A search over posting text** (`hiringJobKeywords`) is slower the first
  time a profile runs; the same search again within minutes is fast.
- **Company descriptions** are read in their first 500 characters.
- **A person's country is where they live**, from their profile; a
  company's country is its headquarters.

### Ready-made examples

Each one opens with the input filled in; press Try for free and change it to your own.

- [Funded Startups Hiring Their First Sales Reps, with Founders](https://apify.com/b2bsearch/full-icp-search/examples/funded-startups-hiring-first-sales-reps): 39 US seed and Series A startups posting AE or SDR jobs in the last 30 days, with founders' emails and the posting. A first sales hire signal.
- [Recently Funded Startups in the USA, with Founders' Emails](https://apify.com/b2bsearch/full-icp-search/examples/recently-funded-us-startups-founders): 1,102 US seed and Series A startups with 11 to 200 staff funded since July 2025, with round, amount, date and founders' emails (count of 31 Oct 2026).

### FAQ

**Is this Clay?** No. It is an independent Actor that covers the
list-building part of a Clay workflow. It is not affiliated with Clay.

**Do I need Claude?** No. The form works on its own and the JSON input can
come from any script, schedule or integration. Claude makes it faster to
describe a profile and compare segments.

**How do I keep the cost under control?** Run `previewOnly` first, set
`maxCompanies` and `maxPeople`, and when calling through the API or MCP set
`maxTotalChargeUsd` on the run: it stops when the budget is spent and keeps
what was delivered.

**Can I rerun weekly and get only new accounts?** Yes: point
`excludeDatasets` at last week's dataset.

**Who reads the reviews and issues?** The people who build it. If a filter
is missing, open an issue.

### Which actor in this family?

| Actor | Input → output |
|---|---|
| **Full ICP Search** (this one) | a profile → companies, people and jobs |
| [B2B Leads Finder](https://apify.com/b2bsearch/b2b-leads-finder) | person filters → leads with a live email, mobile numbers on request |
| [People Database Search](https://apify.com/b2bsearch/people-database-search) | person filters → people, free counts and market breakdowns |
| [Company Database Search](https://apify.com/b2bsearch/company-database-search) | company filters → companies |
| [Hiring Companies Finder](https://apify.com/b2bsearch/hiring-companies-finder) | job search → the employers behind it |
| [Waterfall Lead Enrichment](https://apify.com/b2bsearch/waterfall-lead-enrichment) | your CSV → emails, phones, company data |

### Free Apify plan

Free accounts get the same rows as paid ones, with three limits. A run delivers
at most 100 results when started from Apify Console and 25 when started through
the API, a schedule or an integration; an account gets 500 dataset rows per calendar
month on this Actor, found rows and misses alike; and a row that finds nothing
carries only its status. Previews and counts stay free and outside the monthly
allowance. When a limit stops a run, the status line and the last dataset row say
which limit it was, what is left and when it resets. Any paid Apify plan removes
all of this: Starter is $19/month and includes $19 of usage.

### Feedback and reviews

How did it go? A rating on this Actor's [Reviews page](https://console.apify.com/actors/F5Jmhk1Ibf7bv9wBG/info/reviews)
tells the next buyer what to expect; we read every word. Got a wrong or stale row? Open the **Issues** tab
with the run ID. Issues are public, so leave out emails, phones and names;
the run ID is enough for us to find the row.

### Disclaimer

This Actor is an independent product. It is not affiliated with, endorsed by
or sponsored by Clay Labs or LinkedIn. It does not access, crawl or scrape
any of them at run time: answers come from our own database of publicly
available professional and company data, and the names only describe the
kind of data it covers. To have a person's data removed, open an issue on
this Actor with only the profile link — nothing else is needed, and it is
removed from every listing.

# Actor input Schema

## `find` (type: `string`):

companies_and_people: companies matching the company profile, then up to peoplePerCompany people in each. companies: the companies only. people: people matching the person profile anywhere, at employers matching the company filters.

## `previewOnly` (type: `boolean`):

Count how many companies, people and job postings match, charge nothing and return no rows. Run it first, adjust the filters, then run again with this off.

## `maxCompanies` (type: `integer`):

Stop after this many companies (default 25, at most 5,000). With companies_and_people, companies where nobody matches are skipped free. Free Apify plan: up to 100 from Console, 25 via the API, and 500 rows per month per account.

## `peoplePerCompany` (type: `integer`):

How many people to return per company (default 3, at most 25); a company roster comes most senior first. With find people it also caps people per employer.

## `jobsPerCompany` (type: `integer`):

Add up to this many open job postings per company (0 = none, at most 10): the hiring filter's postings when set, else any posted in the last 90 days. Companies modes only.

## `maxPeople` (type: `integer`):

Stop after this many people across the run (at most 10,000). Default: maxCompanies × peoplePerCompany with companies_and_people, 100 with find people.

## `requireEmail` (type: `boolean`):

On (default): every person has an email that reaches them today — a work address at the current company or a personal one — and is charged as a lead; people without one are skipped free. Off: everyone who matches, without contact details, at the lower person price.

## `emailType` (type: `string`):

Which mailbox counts when requireEmail is on. any: a work address at the current company, else a personal one. work: current-company address only (fewer people). Addresses at earlier employers never count.

## `includePhones` (type: `boolean`):

Each person's verified mobile number on record in phone, charged per person that has one (US-centric, about 1 in 4 US decision makers). Needs requireEmail on. Off: the row only says whether a number is on record (phoneOnRecord).

## `companyCountries` (type: `array`):

Where the companies are headquartered: two-letter codes (us, gb, de...), up to 60. Needed next to a hiring filter that also uses other company filters.

## `industries` (type: `array`):

Company industry names as company pages show them, either wording (Software Development also finds Computer Software), or taxonomy ids. Up to 50. Examples: Financial Services, Venture Capital and Private Equity Principals.

## `companySizeMin` (type: `integer`):

Companies with at least this many employees.

## `companySizeMax` (type: `integer`):

Companies with at most this many employees.

## `companyKeywords` (type: `array`):

Keep companies whose description, name or industry mentions any of these words (shopify, b2b saas, cybersecurity). Up to 10. Read on the rows: pair them with a country, industry or size, or the run reads many companies to find a few.

## `hiringJobTitles` (type: `array`):

Keep companies that posted a job with any of these words in its title (sdr, "data engineer", controller). Whole words. Agencies and job boards are left out. Needs a country (companyCountries or personCountries).

## `hiringJobKeywords` (type: `array`):

Keep companies whose job postings mention any of these words in the posting text (snowflake, "series b", hubspot). Works with hiringPostedWithin week or month; add hiringJobTitles to make it fast.

## `hiringPostedWithin` (type: `string`):

How recent the matching job postings must be.

## `fundingStages` (type: `array`):

The company's latest recorded round: seed means it has not raised past seed yet. Several stages match any of them.

## `fundedAfter` (type: `string`):

Companies whose latest round is dated on or after this day, YYYY-MM-DD (2025-01-01): recently funded companies.

## `foundedAfterYear` (type: `integer`):

Companies founded in or after this year (2020 for young startups).

## `foundedBeforeYear` (type: `integer`):

Companies founded in or before this year.

## `hqCities` (type: `array`):

Headquarters city or region text (austin, california, greater london), 3-64 characters each, at most 10. Narrows the company countries.

## `companyDomains` (type: `array`):

Only these companies, by website domain (stripe.com), up to 1,000: an account-based list. Each domain is the company page that owns it.

## `excludeCompanyDomains` (type: `array`):

Leave out these companies and their people, by website domain: your customers, competitors, your own company. Up to 1,000.

## `seniority` (type: `array`):

Levels of the people. Left empty with no job titles, companies_and_people returns the leadership: founder, C-level, VP, director.

## `jobTitles` (type: `array`):

Words in the person's current job title: any of them matches (sales, "head of marketing", cto). 3-64 characters each, at most 10. Short C-level acronyms match as whole words.

## `excludeJobTitles` (type: `array`):

Drop people whose current title contains any of these words (assistant, intern, junior). 3-64 characters each, at most 10.

## `keywords` (type: `array`):

Words in the person's profile headline — what they say they do or know (kubernetes, revops, fractional cfo, angel investor). 3-64 characters each, at most 10.

## `personCountries` (type: `array`):

Where the people live: two-letter codes (us, gb, de...), up to 60. With a hiring filter, also where the jobs are.

## `personCities` (type: `array`):

City or region text where the people live (new york, berlin, greater london), 3-64 characters each, at most 10.

## `pastCompanyDomains` (type: `array`):

People who used to work at these companies and have left, by website domain: alumni of a competitor, a former customer or a top employer. Up to 100.

## `pastJobTitles` (type: `array`):

Words in a title the person held before (founder, "account executive"): ex-founders, people who moved from sales to marketing. 3-64 characters each, at most 10.

## `yearsExperienceMin` (type: `integer`):

At least this many years since the first job on the profile.

## `yearsExperienceMax` (type: `integer`):

At most this many years since the first job on the profile.

## `startedCurrentRoleAfter` (type: `string`):

People who started their current job on or after this date, YYYY-MM-DD: new hires and recent job changers, the moment a new leader buys.

## `languages` (type: `array`):

Two-letter codes of languages on the profile (en, de, es...), up to 10. Any of them matches.

## `betweenJobs` (type: `boolean`):

Only people with no current position: candidates open to a new role. Works with find people. They are reached at a personal email, and jobTitle and companyName show their last job.

## `keepCompaniesWithoutPeople` (type: `boolean`):

With companies_and_people, also deliver (and charge) companies where nobody matches the person profile. Off: those are skipped free.

## `excludeDatasets` (type: `array`):

Pick datasets of earlier runs: every company and person in them is left out and never charged again. Rerun the same profile weekly and get only new accounts and people.

## Actor input object example

```json
{
  "find": "companies_and_people",
  "previewOnly": false,
  "maxCompanies": 10,
  "peoplePerCompany": 2,
  "jobsPerCompany": 0,
  "requireEmail": true,
  "emailType": "any",
  "includePhones": false,
  "companyCountries": [
    "us"
  ],
  "industries": [
    "Software Development"
  ],
  "companySizeMin": 51,
  "companySizeMax": 200,
  "hiringPostedWithin": "month",
  "seniority": [
    "founder",
    "cxo",
    "vp"
  ],
  "betweenJobs": false,
  "keepCompaniesWithoutPeople": false
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxCompanies": 10,
    "peoplePerCompany": 2,
    "companyCountries": [
        "us"
    ],
    "industries": [
        "Software Development"
    ],
    "companySizeMin": 51,
    "companySizeMax": 200,
    "seniority": [
        "founder",
        "cxo",
        "vp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2bsearch/full-icp-search").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 = {
    "maxCompanies": 10,
    "peoplePerCompany": 2,
    "companyCountries": ["us"],
    "industries": ["Software Development"],
    "companySizeMin": 51,
    "companySizeMax": 200,
    "seniority": [
        "founder",
        "cxo",
        "vp",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("b2bsearch/full-icp-search").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 '{
  "maxCompanies": 10,
  "peoplePerCompany": 2,
  "companyCountries": [
    "us"
  ],
  "industries": [
    "Software Development"
  ],
  "companySizeMin": 51,
  "companySizeMax": 200,
  "seniority": [
    "founder",
    "cxo",
    "vp"
  ]
}' |
apify call b2bsearch/full-icp-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2bsearch/full-icp-search"
        }
    }
}
```

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/F5Jmhk1Ibf7bv9wBG/builds/XkkXmw4P4ndCSN0tl/openapi.json