# AI/ML Hiring Signal Monitor — Track Companies Scaling AI Teams (`bovi/ai-ml-hiring-signal-monitor`) Actor

Track which companies are actively hiring AI/ML roles on LinkedIn — ML engineer, AI researcher, LLM engineer, applied scientist — no login required. Returns job records plus a company-level hiring-velocity signal. Built for AI-focused VCs, talent scouts, and recruiters.

- **URL**: https://apify.com/bovi/ai-ml-hiring-signal-monitor.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Lead generation, Jobs, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 ai/ml hiring signal monitor — track companies scaling ai teams

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### AI/ML Hiring Signal Monitor — Track Companies Scaling AI Teams

Track which companies are actively hiring for AI/ML roles on LinkedIn right now — machine learning engineer, AI researcher, LLM engineer, applied scientist — without logging in or managing cookies. Enter one or more job titles (keywords) and locations — the actor returns a fresh feed of matching job postings with company name, job URL, and posting date.

### Why this matters for VCs and AI recruiters

**AI Investment & VC Intel**: a company posting 5+ "Machine Learning Engineer" or "LLM Engineer" roles this week is heavily scaling its AI initiatives. This is a leading indicator of AI investment, product direction, and growth — catch it before public announcements.

**AI Recruiting**: track when a competitor or target company starts posting AI roles in a new city or function. Source candidates at expanding AI teams or pitch your AI-talent recruiting agency services when they have maximum urgency.

**Market research**: monitor hiring velocity in the AI/ML category (e.g. "applied scientist" in San Francisco) to track demand trends over time.

### Output — two record types

The run emits **job records** (one per posting) and, on top of them, **company hiring-signal
records** — the differentiator: an aggregated, firmographics-enriched B2B prospect list of the
companies that are actively scaling. Filter by `record_type`.

#### Job record fields

| Field | Description |
|---|---|
| `title` | Job title exactly as listed |
| `company` / `company_url` | Company name + LinkedIn company page URL |
| `location` | Location string from the listing |
| `posted_date` | ISO date the job was posted |
| `job_url` / `listing_id` | Direct link + LinkedIn's internal job ID |
| `seniority` | Inferred level: Senior, Junior, Manager, Director, etc. |
| `description_text` | Full job description (detail enrichment) |
| `employment_type` | Full-time / Contract / Part-time (detail) |
| `job_function` | LinkedIn job function (detail) |
| `industries` | Company industry for the role (detail) |
| `applicants` | Applicant count — hiring-urgency signal (detail) |
| `salary` | Salary when LinkedIn surfaces it (detail) |
| `apply_url` | Offsite application URL when present (detail) |
| `skills_mentioned` | Skills from the posting text (e.g. `python`, `pytorch`, `llms`) |
| `search_keyword` / `search_location` | Which query produced this result |
| `parse_confidence` | Data completeness score 0–1 |

#### Company hiring-signal record (`record_type: "company_hiring_signal"`)

Emitted for every company with at least `minOpenRoles` (default 2) open roles in the run.

| Field | Description |
|---|---|
| `company` / `company_url` | Company + LinkedIn page |
| `open_roles_in_run` | How many open roles matched — the scaling signal |
| `hiring_velocity` | `emerging` / `active` / `high` / `aggressive` (by role count) |
| `roles` | List of the open job titles |
| `hiring_locations` | Distinct locations they're hiring in |
| `seniority_breakdown` | Count of roles by inferred seniority |
| `functions_hiring` | Distinct job functions being hired |
| `industries` | Industries inferred from the roles |
| `total_applicants` / `avg_applicants_per_role` | Aggregate demand across the roles |
| `earliest_post` / `latest_post` | Posting-date range (recency of the hiring push) |
| `company_size` / `company_size_tier` | Employee band + tier (Startup→Enterprise) |
| `company_followers` | LinkedIn follower count |
| `company_industry` / `company_hq` / `company_website` | Firmographics from the company page |

### Sample output

```json
[
  {
    "title": "Machine Learning Engineer",
    "company": "Anthropic",
    "company_url": "https://www.linkedin.com/company/anthropicresearch",
    "location": "San Francisco, CA",
    "posted_date": "2026-06-08",
    "job_url": "https://www.linkedin.com/jobs/view/3987654321",
    "listing_id": "3987654321",
    "seniority": null,
    "job_function": "Engineering and Information Technology",
    "industries": "Software Development",
    "applicants": 200,
    "skills_mentioned": ["python", "pytorch", "transformers", "llms", "cuda"],
    "parse_confidence": 1.0
  },
  {
    "record_type": "company_hiring_signal",
    "company": "Anthropic",
    "company_url": "https://www.linkedin.com/company/anthropicresearch",
    "open_roles_in_run": 3,
    "hiring_velocity": "active",
    "roles": ["Machine Learning Engineer", "Senior AI Researcher", "LLM Engineer"],
    "hiring_locations": ["San Francisco, CA", "Seattle, WA"],
    "seniority_breakdown": {"Senior": 1, "Mid-Senior level": 2},
    "functions_hiring": ["Engineering and Information Technology", "Research"],
    "total_applicants": 600,
    "avg_applicants_per_role": 200.0,
    "company_size": "501-1,000 employees",
    "company_size_tier": "Mid-market",
    "company_followers": 1041922,
    "company_hq": "San Francisco, California, US"
  }
]
```

### Input

| Field | Required | Default | Notes |
|---|---|---|---|
| `keywords` | Yes | — | List of job title keywords. Each runs as a separate search. |
| `locations` | No | Global | List of location strings (city, country, region). |
| `postedWithin` | No | `week` | `24h`, `week`, or `month`. |
| `maxItems` | No | 100 | Total results cap (max 1000). |
| `proxyConfiguration` | No | RESIDENTIAL | Apify RESIDENTIAL proxy recommended. |

### Technical notes

- Uses LinkedIn's public guest jobs API (no login, no cookies required).
- Apify RESIDENTIAL proxy for reliability.
- Deduplicates results across keyword/location combinations.
- Results capped at 1000 per run; use multiple runs for larger volumes.

### 💰 Pricing & how we compare

**Pay-per-result (PPE): from $3.00 / 1K results.** You are billed per `job-result` actually returned — plus the tiny
`apify-actor-start` fee Apify waives for short runs. No subscription, no API key, no proxy fee on top.

**Our edge:** Company hiring-velocity signal (who is ramping) · per-job detail enrichment · no cookies, no login.

**Pricing examples** (pay only for what you get, minus Apify's 20%):

| Volume | Cost |
|---|---|
| 100 results | $0.30 |
| 1,000 results | $3.00 |
| 10,000 results | $30.00 |

#### How rivals price the same job (live Apify Store, checked 2026-06-09)

| Actor | Their price | What they lack vs us |
|---|---|---|
| `agentx/linkedin-jobs-scraper` | $2.80/1K | 5★ full taxonomy, but no company-velocity hiring signal |
| `scrapemint/linkedin-jobs-scraper-pro` | FREE | 56% success rate — unreliable at scale |

*Prices above are competitors' live Store prices at the time of writing; ours is set to sit just
below the strongest comparable while returning richer, quality-scored data.*

### 🤖 Use with AI agents (MCP)

This actor is agent-ready (category **MCP\_SERVERS**). Point any MCP client (Claude Desktop, Cursor,
n8n AI, LangGraph) at it:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=bovi/ai-ml-hiring-signal-monitor",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Linkedin Profile Scraper](https://apify.com/bovi/linkedin-profile-scraper)
- [PagesJaunes Directory Scraper](https://apify.com/bovi/pagesjaunes-directory)
- [Skip Trace People Finder](https://apify.com/bovi/skip-trace-people-finder)
- [Trustpilot Reviews Scraper](https://apify.com/bovi/trustpilot-reviews-scraper)
- [Upwork Talent Scraper](https://apify.com/bovi/upwork-talent-scraper)
- [Website Contact Extractor](https://apify.com/bovi/website-contact-extractor)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

# Actor input Schema

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

Job title keywords to search for. Each keyword runs as a separate search. Examples: \["data engineer", "software engineer", "account executive"]. You can target by role to find companies scaling specific functions.

## `locations` (type: `array`):

Locations to search in. Use city names, country names, or region names that LinkedIn recognizes. Examples: \["United States", "San Francisco Bay Area", "London", "Germany"]. Leave empty to search globally.

## `postedWithin` (type: `string`):

Filter jobs by how recently they were posted. '24h' = last 24 hours (freshest signals), 'week' = last 7 days, 'month' = last 30 days.

## `maxItems` (type: `integer`):

Maximum total job listings to return across all keyword+location combinations. Each returned item is one charge. For a quick company pulse, 50–100 is usually enough. Max cap is 1000 per run.

## `scrapeDetails` (type: `boolean`):

Fetch each job's detail page for description, applicant count, salary, employment type, job function, industries, and skills mentioned. ON = richest data (recommended). OFF = faster, search-card fields only.

## `minOpenRoles` (type: `integer`):

A company is emitted as a 'company\_hiring\_signal' record (with firmographics + hiring breakdown) when it has at least this many open roles in the run — your sales trigger for actively-scaling companies. Default 2.

## `proxyConfiguration` (type: `object`):

Apify proxy settings. RESIDENTIAL proxy is strongly recommended — LinkedIn's guest API rate-limits datacenter IPs.

## Actor input object example

```json
{
  "keywords": [
    "sales manager",
    "marketing director"
  ],
  "locations": [
    "United Kingdom",
    "San Francisco Bay Area"
  ],
  "postedWithin": "week",
  "maxItems": 200,
  "scrapeDetails": true,
  "minOpenRoles": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing Hiring Signal Monitor records (record\_type, title, company, company\_url, location, posted\_date, seniority, employment\_type, applicants, hiring\_velocity, job\_url, parse\_confidence).

# 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 = {
    "keywords": [
        "machine learning engineer",
        "AI researcher",
        "LLM engineer",
        "applied scientist"
    ],
    "locations": [
        "United States"
    ],
    "postedWithin": "week",
    "maxItems": 100,
    "scrapeDetails": true,
    "minOpenRoles": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/ai-ml-hiring-signal-monitor").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 = {
    "keywords": [
        "machine learning engineer",
        "AI researcher",
        "LLM engineer",
        "applied scientist",
    ],
    "locations": ["United States"],
    "postedWithin": "week",
    "maxItems": 100,
    "scrapeDetails": True,
    "minOpenRoles": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/ai-ml-hiring-signal-monitor").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 '{
  "keywords": [
    "machine learning engineer",
    "AI researcher",
    "LLM engineer",
    "applied scientist"
  ],
  "locations": [
    "United States"
  ],
  "postedWithin": "week",
  "maxItems": 100,
  "scrapeDetails": true,
  "minOpenRoles": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/ai-ml-hiring-signal-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bovi/ai-ml-hiring-signal-monitor"
        }
    }
}

```

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/9n7568YuxlZfd68YX/builds/hveWy56hGlkLBPWam/openapi.json