# Companies Hiring For Any Role — Hiring Signals & Sales Leads (`viridian_layout_ea2/companies-hiring-leads`) Actor

Find every company hiring for a role, e.g. Salesforce admins or data engineers: one row per company with matching roles, new roles this week and month, total openings, hiring growth, departments, locations and pay. 19,000+ companies' career sites, updated daily.

- **URL**: https://apify.com/viridian_layout_ea2/companies-hiring-leads.md
- **Developed by:** [CMM Research](https://apify.com/viridian_layout_ea2) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 companies

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

## Companies Hiring For Any Role — Hiring Signals & Sales Leads

Find **every company that's hiring for a role you care about**, and get one row per
company instead of thousands of job ads. Search for "Salesforce", "data engineer", "SDR" or
any title. You get back each company with how many matching roles it has open, how many are
new this week and this month, its total openings and hiring growth, top departments and
locations, the pay it advertises, and links to the roles.

It searches a **daily index of 1.8M+ open jobs on 19,000+ companies' own career sites**
(Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Oracle and 13 more hiring systems), so a
search across all of them takes about a minute. You don't need any coding, logins or proxies.

*Built and maintained by CMM Research.* Need a custom feed? Email us at
<chazmichael_michaels@icloud.com>.

**Who uses it**

- **Sales teams selling to a job function.** A company hiring three Salesforce admins needs
  Salesforce consultants, tools and training. A company hiring SDRs is building a sales team.
  Hiring is a public, dated buying signal.
- **Recruiting and staffing agencies.** Find the companies with the most open roles in your
  specialty, and spot the ones hiring fastest.
- **Market research.** See which companies are investing in a skill, where, and at what pay.

**A real result** (search: `salesforce` in the United States, 14 Oct 2026):

```json
{
  "companyName": "ICF",
  "ats": "workday",
  "careerSiteUrl": "https://icf.wd5.myworkdayjobs.com/ICFExternal_Career_Site",
  "matchingJobs": 12,
  "matchingJobsNewLast7Days": 1,
  "matchingJobsNewLast30Days": 12,
  "totalOpenJobs": 397,
  "newJobsLast30Days": 256,
  "hiringGrowth": 0.64,
  "topDepartments": [{ "name": "Information Technology", "jobs": 11 }],
  "topLocations": [{ "name": "Reston, VA", "jobs": 11 }],
  "salaryMin": 67355,
  "salaryMax": 245448,
  "salaryCurrency": "USD",
  "sampleTitles": "Salesforce Developer- Remote; Salesforce Technical Consultant and Project Manager; Salesforce Business Analyst; Salesforce Administrator; Salesforce Quality Assurance Analyst",
  "sampleJobs": [
    { "title": "Salesforce Developer- Remote", "location": "Reston, VA", "postedAt": "2026-10-13", "url": "https://icf.wd5.myworkdayjobs.com/ICFExternal_Career_Site/job/Reston-VA/Salesforce-Developer--Remote_R2603468" }
  ]
}
```

Here, all 12 Salesforce roles were posted this month, and 64% of ICF's 397 openings are under 30 days old.

> **Want the jobs themselves?** Our [Career Site Jobs API](https://apify.com/viridian_layout_ea2/career-site-jobs-api)
> searches the same index and returns one row per job, with descriptions and salaries.

### Why this one

- **Companies, not job ads.** Most hiring-signal tools either check a list of companies you
  already have, or hand you thousands of job ads to sort through. This one starts from every
  company in the index and tells you who is hiring, one row each.
- **Size and momentum in every row.** Matching roles and *all* openings, plus how many are
  new in the last 7 and 30 days. `hiringGrowth` is the share of a company's openings posted in
  the last 30 days, so you can sort for companies in a hiring push. Ages come from the posting
  date; a role without one counts only once we've watched the company's site for the whole
  window, so a company new to the index doesn't look like it posted everything this month.
  Bulk re-posts don't count as new either: when one posting date holds more than 40% of a
  company's roles (20 or more), the roles on it that were already open when we started
  watching the site are treated as old openings with refreshed dates. And a role never counts
  as newer than the day we first saw it, so re-posting an old ad doesn't make it new.
  When fewer than half of a company's roles have a known age, `hiringGrowth` is empty and the
  company sorts last for growth.
- **Ghost listings filtered out.** Some career sites never take old ads down. Roles posted
  more than a year ago are left out of every count by default (`maxRoleAgeDays`).
- **Only new signals, on a schedule.** With `onlyNewSinceLastRun`, each scheduled run returns
  only companies that posted a matching role since the last run.
- **Pay where stated.** The pay range across a company's matching roles, read from the
  postings, per year.
- **Pay only for what you get.** Filters run before charging, so you're charged per company
  delivered, never per job scanned.

### Pricing

**$20 per 1,000 companies** ($0.02 per company), plus Apify's standard $0.00005 run-start fee.
On Apify's paid plans it's cheaper: $18 (Starter), $16 (Scale) or $14 (Business) per 1,000.
Platform usage is included, so you are not billed for compute separately. Every job in the
index is scanned on every run at no extra cost; you pay only for the companies returned.

- **`maxCompanies`** is a hard cap per run (default 200).
- **Apify's maximum cost per run** also works: if the limit is reached, the Actor stops
  cleanly and keeps everything delivered so far.

### Input

| Field | What it does |
|---|---|
| `titleKeywords` | The role you're looking for, e.g. `["salesforce"]`, `["data engineer", "analytics engineer"]`. |
| `titleExcludeKeywords` | Leave out titles containing these, e.g. `["intern"]`. |
| `locationKeywords` | Only count roles in these places, e.g. `["United States"]`, `["Texas"]`. |
| `remoteOnly` | Only count remote roles. |
| `postedWithinDays` | Only count roles posted in the last N days. |
| `minMatchingJobs` | Only companies with at least this many matching roles. |
| `minTotalOpenJobs` / `maxTotalOpenJobs` | Company size by total openings. |
| `sortBy` | Most matching roles, most new matching roles, fastest hiring growth, or most openings. |
| `companyKeywords` | Only companies whose name contains these (check a target-account list). |
| `sources` | Only some hiring systems. |
| `onlyWithSalary` / `minAnnualSalary` / `salaryCurrencies` | Only count roles that state pay, or pay at least this much. |
| `maxRoleAgeDays` | Ignore roles posted longer ago than this (default 365; 0 keeps all). |
| `onlyNewSinceLastRun` / `monitorName` | Only companies with matching roles added since this search last ran. |
| `maxCompanies` | Cap on results, and your main cost control. |

### Output

| Field | Description |
|---|---|
| `companyName` / `companyId` | Company name, and its stable id on its hiring system |
| `ats` / `careerSiteUrl` | Which hiring system it uses, and its jobs page |
| `matchingJobs` | Open roles matching your search |
| `matchingJobsNewLast7Days` / `matchingJobsNewLast30Days` | How many of those are new |
| `matchingJobsNewSinceLastRun` | With `onlyNewSinceLastRun`: matching roles added since the last run |
| `latestMatchingPostedAt` | Newest matching posting |
| `totalOpenJobs` / `newJobsLast7Days` / `newJobsLast30Days` | All open roles at the company, and how many are new |
| `hiringGrowth` | Share of openings posted in the last 30 days (0–1), among roles of known age, not counting bulk re-posts; empty when too few roles are dated |
| `matchingRemoteJobs` | Matching roles marked remote |
| `topDepartments` / `topLocations` / `countries` | Where the matching roles sit |
| `salaryMin` / `salaryMax` / `salaryCurrency` / `matchingJobsWithSalary` | Yearly pay range across matching roles that state it |
| `sampleJobs` / `sampleTitles` | The 5 newest matching roles, with links |
| `indexedAt` | When the index was last refreshed |

### Examples

**Companies hiring Salesforce people in the US**

```json
{ "titleKeywords": ["salesforce"], "locationKeywords": ["United States"], "maxCompanies": 500 }
```

**Mid-size companies building a sales team this month**

```json
{ "titleKeywords": ["SDR", "BDR", "sales development"], "postedWithinDays": 30, "maxTotalOpenJobs": 500, "sortBy": "newMatchingJobs" }
```

**Weekly: companies newly hiring data engineers (schedule weekly)**

```json
{ "titleKeywords": ["data engineer"], "onlyNewSinceLastRun": true, "maxCompanies": 1000 }
```

**Which of my target accounts are hiring security engineers?**

```json
{ "companyKeywords": ["stripe", "datadog", "cloudflare"], "titleKeywords": ["security"] }
```

### Use it from Claude, Cursor or any AI agent (MCP)

Apify's hosted MCP server lets an AI assistant run this Actor as a tool. It writes the
input from a plain-English request and reads back the results. Add this to your client's
MCP settings (Claude Desktop, Cursor, VS Code, Windsurf and others):

```json
{
  "mcpServers": {
    "companies-hiring": {
      "url": "https://mcp.apify.com?tools=viridian_layout_ea2/companies-hiring-leads"
    }
  }
}
```

The first time it connects, a browser window opens so you can sign in to Apify. If your
client can't do that, add `"headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }`.
You'll find your token under **Settings → API & Integrations** in Apify Console.

In Claude Code, run this once:

```bash
claude mcp add --transport http companies-hiring "https://mcp.apify.com?tools=viridian_layout_ea2/companies-hiring-leads"
```

Then ask in plain English, for example:

- *"Which US companies are hiring Salesforce administrators or developers right now? Biggest hirers first."*
- *"Find mid-size companies that posted SDR or BDR roles in the last 30 days."*
- *"Which of these companies are hiring security engineers: Datadog, Snowflake, HubSpot, Okta?"*

Runs started by an agent are billed exactly like any other run, at $20 per 1,000 companies
($14–$18 on paid Apify plans). Ask it to set `maxCompanies` if you want a hard cap.

### Notes

- **Coverage.** The index covers companies that post jobs on their own career site through
  one of 19 hiring systems: 19,000+ companies, from startups to the Fortune 500. Companies
  that only post on LinkedIn or Indeed aren't included. It is refreshed daily.
- **Company names.** Most come from the career site. For Lever and Ashby, which only expose
  an id, the name is made readable from it ("cullen-jewellery" → "Cullen Jewellery").
- **No contact details.** You get the company and its careers page, not people's emails. Pair
  it with an enrichment tool if you need contacts.
- A role's age is its posting date, or the day the index first saw it when the site gives no
  date.
- `onlyNewSinceLastRun` remembers each search in a key-value store named
  `hiring-companies-monitor` in your own Apify account.

# Actor input Schema

## `titleKeywords` (type: `array`):

Companies with open roles whose title contains one of these, e.g. "salesforce", "data engineer", "SDR". Short keywords (3 letters or fewer) match whole words only.

## `titleExcludeKeywords` (type: `array`):

Drop roles whose title contains any of these, e.g. "intern", "senior".

## `locationKeywords` (type: `array`):

Only count roles where any listed location (or the country) contains one of these, e.g. "United States", "Texas", "London".

## `remoteOnly` (type: `boolean`):

Only count roles whose location or workplace label says remote.

## `postedWithinDays` (type: `integer`):

Only count matching roles posted in the last N days, e.g. 30 for companies actively hiring for it now.

## `minMatchingJobs` (type: `integer`):

Only companies with at least this many open roles matching your search.

## `minTotalOpenJobs` (type: `integer`):

Only companies with at least this many open roles in total (any role). A rough company-size filter.

## `maxTotalOpenJobs` (type: `integer`):

Only companies with at most this many open roles in total, e.g. 300 to skip the giants and find mid-size companies.

## `sortBy` (type: `string`):

Which companies come first. The maximum below keeps the top of this list.

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

Only companies whose name contains one of these, e.g. to check a list of target accounts.

## `sources` (type: `array`):

Limit to some systems. Leave empty for all.

## `onlyWithSalary` (type: `boolean`):

Only count roles whose posting states pay.

## `minAnnualSalary` (type: `integer`):

Only count roles whose pay range reaches at least this much per year, in the job's own currency.

## `salaryCurrencies` (type: `array`):

Only roles paying in these currencies, e.g. "USD", "GBP", "EUR". Implies 'only jobs that state pay'.

## `maxRoleAgeDays` (type: `integer`):

Some career sites never take old ads down. Roles posted longer ago than this are left out of every count. Set 0 to keep everything.

## `onlyNewSinceLastRun` (type: `boolean`):

For scheduled runs: return only companies that posted a matching role since this same search last ran, i.e. fresh hiring signals. The Actor remembers each search in a key-value store named <code>hiring-companies-monitor</code> in your account; changing any filter starts a new history.

## `monitorName` (type: `string`):

Only needed to keep two searches with identical filters separate, e.g. one per client.

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

Hard cap on results, and your main cost control: you are charged per company returned. The top companies by the chosen sort come first.

## Actor input object example

```json
{
  "titleKeywords": [
    "salesforce"
  ],
  "titleExcludeKeywords": [],
  "locationKeywords": [],
  "remoteOnly": false,
  "minMatchingJobs": 1,
  "sortBy": "matchingJobs",
  "companyKeywords": [],
  "sources": [],
  "onlyWithSalary": false,
  "salaryCurrencies": [],
  "maxRoleAgeDays": 365,
  "onlyNewSinceLastRun": false,
  "maxCompanies": 200
}
```

# Actor output Schema

## `companies` (type: `string`):

Every company delivered: matching roles, new roles, total openings, hiring growth, departments, locations, pay and example roles.

## `summary` (type: `string`):

Companies and roles matched, index date, and why the run stopped.

# 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 = {
    "titleKeywords": [
        "salesforce"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("viridian_layout_ea2/companies-hiring-leads").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 = { "titleKeywords": ["salesforce"] }

# Run the Actor and wait for it to finish
run = client.actor("viridian_layout_ea2/companies-hiring-leads").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 '{
  "titleKeywords": [
    "salesforce"
  ]
}' |
apify call viridian_layout_ea2/companies-hiring-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,viridian_layout_ea2/companies-hiring-leads"
        }
    }
}
```

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/aYrYbWxHfi5ugoAwK/builds/cwWooKl2RfqygXQGf/openapi.json