# AI Hiring Signals (`schesds/ai-hiring-signals`) Actor

Detect AI hiring activity from LinkedIn company job listings and return company-level signals for market intelligence, sales, recruiting, and strategy teams.

- **URL**: https://apify.com/schesds/ai-hiring-signals.md
- **Developed by:** [Tedd Shesden](https://apify.com/schesds) (community)
- **Categories:** Jobs, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$7.00 / 1,000 ai job analyzeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Hiring Signals

Detect AI hiring activity from LinkedIn company job listings and turn open roles into company-level market signals.

This Actor is designed for sales, recruiting, strategy, market intelligence, and investment research teams that want to identify which companies are building AI, machine learning, data science, LLM, agentic AI, and AI-adjacent teams.

### What You Get

For each LinkedIn company input, the Actor analyzes available job listings and returns:

- One `ai_hiring_signal` row with the company-level summary
- One `ai_hiring_job` row for every analyzed job listing, with `isAiJob` showing whether the job was classified as AI-related

- Total jobs analyzed for the company
- AI jobs detected from job titles, functions, and skills
- AI hiring share
- AI hiring signal strength: `NONE`, `LOW`, `MEDIUM`, or `HIGH`
- Detected signals such as `AI_HIRING_PRESENT`, `AI_HIRING_CONCENTRATION`, `RECENT_AI_HIRING`, `AI_ENGINEERING_HIRING`, `DATA_SCIENCE_HIRING`, and `AI_PRODUCT_HIRING`
- AI keywords, role categories, top AI job titles, locations, seniority, and job-level evidence
- Full analyzed job rows with title, URL, location, date, seniority, function, skills, and AI flags
- Context fields for engineering, product, and go-to-market hiring
- Clean error rows for inputs that could not be analyzed

### Use Cases

- Identify companies actively hiring AI and data teams
- Monitor AI adoption signals across target accounts
- Track competitors' AI hiring momentum
- Build monthly AI hiring signal datasets
- Enrich CRM, market maps, and investment research workflows

### Input

Add one or more LinkedIn company IDs or LinkedIn company jobs/search URLs. You can also edit the AI job keyword list used to flag jobs as AI-related.

#### Example

```json
{
  "companyInputs": [
    "30898036"
  ],
  "aiJobKeywords": [
    "AI",
    "Artificial Intelligence",
    "Machine Learning",
    "ML",
    "Generative AI",
    "GenAI",
    "LLM",
    "Data Science",
    "Data Scientist",
    "Prompt Engineer",
    "AI Agent"
  ]
}
````

You can also use a LinkedIn jobs/search URL:

```json
{
  "companyInputs": [
    "https://www.linkedin.com/jobs/search/?f_C=30898036"
  ]
}
```

#### AI job keywords

`aiJobKeywords` controls the `isAiJob` flag. A job is marked `isAiJob=true` when its title, function, or skills contain at least one configured term. If you omit this field, the Actor uses its default AI keyword list. If you provide the field, your list defines the matching criteria for that run.

### Output

The default dataset view is `results`.

The dataset includes:

- `ai_hiring_signal`: company-level summary row
- `ai_hiring_job`: one row per analyzed job listing, including `isAiJob`, AI keywords, and AI role categories
- `scrape_error`: failed inputs with `failureStage` and `errorMessage`

Results can be exported from Apify as JSON, CSV, Excel, XML, RSS, or HTML.

### Pricing

When pay-per-event monetization is enabled, the Actor charges one event for each delivered `ai_hiring_job` row.

For example, if one company has 163 available job listings, the Actor returns one company summary row plus 163 job rows, and charges 163 `ai-job-analyzed` events. Failed inputs and companies with no returned jobs are not charged.

### Notes

- Field coverage depends on what is available for the company's LinkedIn job listings.
- AI classification is based on the configured `aiJobKeywords` matched against job title, job function, and skills. This avoids over-counting generic company boilerplate that mentions AI in every job description.
- The Actor returns both company-level AI hiring signals and the job-level rows used to support those signals.

# Actor input Schema

## `companyInputs` (type: `array`):

Add LinkedIn company IDs or company jobs/search URLs. The Actor returns one company-level summary plus one row for every analyzed job. Example company ID: 30898036. Example URL: https://www.linkedin.com/jobs/search/?f\_C=30898036

## `aiJobKeywords` (type: `array`):

Terms used to flag a job as AI-related. A job is marked isAiJob=true when its title, function, or skills contain at least one of these terms. Edit, remove, or bulk-add terms to match your definition of AI hiring.

## Actor input object example

```json
{
  "companyInputs": [
    "30898036"
  ],
  "aiJobKeywords": [
    "AI",
    "Artificial Intelligence",
    "Machine Learning",
    "ML",
    "Deep Learning",
    "Generative AI",
    "GenAI",
    "LLM",
    "Large Language Model",
    "Data Scientist",
    "Data Science",
    "NLP",
    "Natural Language Processing",
    "Computer Vision",
    "Research Scientist",
    "Applied Scientist",
    "Prompt Engineer",
    "Agentic AI",
    "AI Agent"
  ]
}
```

# 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 = {
    "companyInputs": [
        "30898036"
    ],
    "aiJobKeywords": [
        "AI",
        "Artificial Intelligence",
        "Machine Learning",
        "ML",
        "Deep Learning",
        "Generative AI",
        "GenAI",
        "LLM",
        "Large Language Model",
        "Data Scientist",
        "Data Science",
        "NLP",
        "Natural Language Processing",
        "Computer Vision",
        "Research Scientist",
        "Applied Scientist",
        "Prompt Engineer",
        "Agentic AI",
        "AI Agent"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("schesds/ai-hiring-signals").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 = {
    "companyInputs": ["30898036"],
    "aiJobKeywords": [
        "AI",
        "Artificial Intelligence",
        "Machine Learning",
        "ML",
        "Deep Learning",
        "Generative AI",
        "GenAI",
        "LLM",
        "Large Language Model",
        "Data Scientist",
        "Data Science",
        "NLP",
        "Natural Language Processing",
        "Computer Vision",
        "Research Scientist",
        "Applied Scientist",
        "Prompt Engineer",
        "Agentic AI",
        "AI Agent",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("schesds/ai-hiring-signals").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companyInputs": [
    "30898036"
  ],
  "aiJobKeywords": [
    "AI",
    "Artificial Intelligence",
    "Machine Learning",
    "ML",
    "Deep Learning",
    "Generative AI",
    "GenAI",
    "LLM",
    "Large Language Model",
    "Data Scientist",
    "Data Science",
    "NLP",
    "Natural Language Processing",
    "Computer Vision",
    "Research Scientist",
    "Applied Scientist",
    "Prompt Engineer",
    "Agentic AI",
    "AI Agent"
  ]
}' |
apify call schesds/ai-hiring-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=schesds/ai-hiring-signals",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Hiring Signals",
        "description": "Detect AI hiring activity from LinkedIn company job listings and return company-level signals for market intelligence, sales, recruiting, and strategy teams.",
        "version": "0.1",
        "x-build-id": "JJb8q65NpuaZFne8b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/schesds~ai-hiring-signals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-schesds-ai-hiring-signals",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/schesds~ai-hiring-signals/runs": {
            "post": {
                "operationId": "runs-sync-schesds-ai-hiring-signals",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/schesds~ai-hiring-signals/run-sync": {
            "post": {
                "operationId": "run-sync-schesds-ai-hiring-signals",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companyInputs"
                ],
                "properties": {
                    "companyInputs": {
                        "title": "LinkedIn company IDs or jobs URLs",
                        "type": "array",
                        "description": "Add LinkedIn company IDs or company jobs/search URLs. The Actor returns one company-level summary plus one row for every analyzed job. Example company ID: 30898036. Example URL: https://www.linkedin.com/jobs/search/?f_C=30898036",
                        "items": {
                            "type": "string"
                        }
                    },
                    "aiJobKeywords": {
                        "title": "AI job keywords",
                        "type": "array",
                        "description": "Terms used to flag a job as AI-related. A job is marked isAiJob=true when its title, function, or skills contain at least one of these terms. Edit, remove, or bulk-add terms to match your definition of AI hiring.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
