When someone starts a company they're not ready to talk about, they still update their own work history. They write "Stealth" in the employer field, or "Stealth Startup," or "Stealth Mode," or something vague.
On the outside this looks like a generic way to hide information. From inside a dataset of public professional records, you've got yourself a filterable signal with 37,801 matches.
That number is too large to act on yet too specific to ignore. This piece walks the narrowing from 37,801 to 37, one filter at a time, with the result count after every step. The queries we're presenting here are real and the numbers came from running the experiment.
Employer text is the first of three signals a company leaves before it has a website. The second is size: a company with four employees is a different object from one with four hundred, and headcount is the cheapest available proxy for stage. The third is money, which arrives with a date attached and is reported publicly whether or not the company wants attention.
None of these factors tell you much, so let's see what happens when we stack them.
What is a stealth startup?
A stealth startup is a company that operates without announcing itself. It may have no website, no press release and no public product, and sometimes no public name. Founders stay quiet to build before competitors notice, to hire without signaling their plans, or because they haven't settled on what they're building yet.
Investors look for stealth startups to meet founders before a round is crowded, recruiters look for them to reach people who are about to hire, and sales teams look for them to sell into a company before its stack is set. Stealth doesn't mean invisible, though. The people involved still leave a public trail, and the rest of this piece follows it.
Start with what people call their own employer
When someone joins a company that hasn't launched, they still need to put something in the employer field. A large number of them write some variant of "Stealth."
Person Search filters on that text directly with current_company_name, which accepts Boolean expressions:
GET /api/v2/search/person
?current_company_name="Stealth" || "Stealth Startup" || "Stealth Mode"
That returns 37,801 people.
The Boolean operator is key here. The same query with a single exact term returns 8,547, so the variants add value. If you write this filter as one term you miss a huge chunk of the population.
37,801 is a large number and also a useless one because nobody reviews 37,801 profiles. Everything below is the work of getting that to a number to something actually useable.
Narrow by company size
Person Search did not always have a company-size filter. But it does now, and for this method it's the single most valuable parameter available.
¤t_company_employee_count_max=50
That takes 37,801 to 304.
One filter removes 99.2% of the result set. The reason it cuts so hard is that "Stealth" is not only used by unannounced startups. It is also used by people at established companies working on an internal project they can't name, by consultants between engagements, and by anyone who wants a placeholder. Company size separates the founder of a four-person company from a program manager at a large one, and no amount of title filtering does that job as well.
A caution on the number itself: Headcount from professional profiles is noisy, it reflects who has updated their own profile rather than a payroll figure, and it lags reality at exactly the companies you care about most. Treat the size filter as a stage proxy rather than a measurement. It's good enough to sort a list, but don't quote it.
Filter for the people who start things
Working at an early company and starting one are different signals, and the title field separates them:
¤t_role_title="Founder" || "Co-Founder" || "CEO"
304 becomes 63.
Recency narrows it further. current_role_after filters on when the current role began, which is a reasonable stand-in for when the company started:
¤t_role_after=2025-01-01
63 becomes 37.
Thirty-seven is a reasonable list, which is the point of this exercise.
Two other parameters are worth a mention at this stage: past_company_name filters on where someone worked before, which is how you express a thesis about founder background. education_school_name does the same for education. Both accept Boolean expressions, and both narrow aggressively, so add them one at a time and check the count before adding the next.
Exclusion is available too, with a leading hyphen, and it's useful for stripping out title noise like assistant or advisor roles. Verify the effect on your own query, because exclusion interacts with grouping in ways that are easy to get wrong.
Funding is a separate entry point
The method above starts from people. You can also start from companies, using funding as the opening filter. Company Search takes an amount and a date window:
GET /api/v2/search/company
?funding_raised_after=2025-01-01
&funding_amount_min=1000000
That returns 16,075 companies, which is your starting number, and it narrows the same way with employee_count_max, founded_after_year, and industry.
These filters are reliable for selecting companies. Filtering by funding amount and date works, but inspecting what the company actually raised, round by round, doesn't return the full picture. Use the filter to find, and use another source to verify.
Size the query before you spend on it
Every query above was run with page_size=1, because search responses include total_result_count whether you ask for one result or a hundred. That means you can build the whole narrowing sequence at the smallest possible page size, watch the count move, and only widen it once the filters are right.
This actually matters. The difference between a well-built query and a first attempt is usually two orders of magnitude in result count, and discovering that after pulling full pages is an avoidable way to spend credits. Build the funnel at page_size=1, then open it up.
Watching a company after you find it
A found company is a snapshot. The v2 search endpoints and the employee-count endpoint both answer questions about the present: current_role_after filters on when a role began, and /api/v2/company/employees/count returns a count as of the request. Neither returns a series you can plot.
Direction, for now, is something you assemble. Store the count each time you check, keep the date next to it, and compare across checks. A company that went from eight people to forty in six months and a company that has been at forty for three years return the same number today, and the difference between them is the entire signal.
That accumulation is worth automating early, because the history only starts on the day you begin recording it.
The shape of the method
The queries in this piece narrowed 37,801 records to 37 in four filters: employer text, company size, role title, and role recency. Each one is a single parameter. The sequence matters more than any individual filter, and the count after each step is the only reliable way to know whether the query is working.
Start at page_size=1, add one parameter at a time, and stop when the number is small enough to read.
