# Company Hiring Signals | Who Is Hiring by Domain API (`berkaydev/company-hiring-signals`) Actor

Check a list of company domains and see which companies are hiring right now: open positions, job titles, career page and ATS. Reads ATS feeds (Personio, Greenhouse, Lever, Ashby…) and the company's own career page. Pay only per company with jobs found.

- **URL**: https://apify.com/berkaydev/company-hiring-signals.md
- **Developed by:** [Gezgin Data](https://apify.com/berkaydev) (community)
- **Categories:** Lead generation, Jobs, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 company with open positions

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

Give it a list of company domains and get back **which of these companies are hiring right now**: the number of open positions, every job title, where each one was found, the career page and the applicant tracking system the company uses. One row per company, no login, no browser, and you **pay only for companies with open positions**.

### Who uses it

**Recruiting and staffing agencies** check their target companies every week and call the ones that just opened new positions. **Sales teams** use hiring as a buying signal, because a company that hires warehouse staff, salespeople or developers is growing and spending. **HR software and job board sellers** find out which prospects run their own career page, which use Personio or Greenhouse, and how many roles they advertise. **Market researchers** track hiring across a region or an industry.

### Why it finds jobs other job scrapers miss

Most job scrapers read applicant tracking systems such as Greenhouse, Lever or Workday. That works for tech companies, but most small and mid-sized businesses have no ATS at all: they put their openings straight onto their own website. In our test of 53 German manufacturers and wholesalers, only 4 used an ATS, while 14 more listed their jobs on their own career page.

This Actor reads both. When a career page links an ATS with a public job feed (Personio, Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee), it reads that official feed. Otherwise it reads the company's own career pages: the structured JobPosting data that Google for Jobs uses, and job titles carrying a gender marker such as "(m/w/d)", "(m/f/d)" or "(all genders)", which in Germany, Austria and Switzerland practically every job ad has. In that test it found open positions at 18 of 60 reachable companies, and every one of 25 randomly checked titles was a real job.

**It plugs into the other Gezgin Data Actors.** Pass the dataset of a [Google Maps Email Scraper](https://apify.com/berkaydev/google-maps-email-scraper-business-leads) run as `datasetId` and you check every business from your map search in one go. Feed the hiring companies to [Company Email Finder by Domain](https://apify.com/berkaydev/company-email-finder-by-domain) and you have their published company mailboxes too, or to the [Website Technology Detector](https://apify.com/berkaydev/website-technology-detector) to see what their websites run on.

**Weekly hiring alerts.** Turn on `onlyNewJobs` and schedule the run weekly. Each company remembers the positions it had before, so you get only companies that opened new roles since the last run, and only those are charged.

**Pay transparency check.** The EU Pay Transparency Directive will require employers to state pay or a pay range in job ads. Turn on `checkSalary` and the Actor opens each job ad (up to `maxSalaryChecksPerCompany`) and records whether it names an amount or range, for example "2,200–2,500 EUR per month", or a collective agreement such as "nach Tarif" or TVöD. A vague "attractive salary" does not count. Each job gets a `salary` field, and the company row shows `jobsWithSalary` and `salaryTransparencyPct`. In our test, about one in five job ads of German mid-sized companies stated pay or a collective agreement. HR consultants and recruiters use this to see which employers are not ready yet.

### Input example

```json
{
  "domains": ["delker.com", "gundlach-packaging.com", "n8n.io"],
  "jobKeywords": ["lager", "logistik", "sales"],
  "onlyHiring": true
}
```

Or chain it to an earlier run: `{"datasetId": "<dataset ID>", "onlyHiring": true}`.

### Output example

```json
{
  "domain": "gundlach-packaging.com",
  "hiring": true,
  "jobCount": 10,
  "jobTitles": ["Ausbildung zum Fachlagerist (m/w/d)", "Ausbildung zum Industriemechaniker (m/w/d)", "..."],
  "apprenticeshipCount": 7,
  "jobs": [
    {
      "title": "Ausbildung zum Fachlagerist (m/w/d)",
      "location": "Oerlinghausen",
      "department": "Ausbildung",
      "url": "https://gundlach.jobs.personio.de/job/1234567",
      "postedAt": "2026-10-02T09:12:00+00:00",
      "source": "personio"
    }
  ],
  "ats": "personio",
  "atsFeedRead": true,
  "careerPage": "https://www.gundlach-packaging.com/join-the-crew",
  "summary": "10 open positions, e.g. Ausbildung zum Fachinformatiker - Systemintegration (m/w/d), ...",
  "statusNote": null
}
```

`hiring` is `true` when open positions were found, `false` when a career page exists but nothing is open, and `null` when the website has no career page at all. Every row without positions explains itself in `statusNote`. The run summary (companies checked, companies hiring, hiring rate, ATS seen) is in the key-value store under `RUN_STATUS`. You can download the dataset as JSON, CSV, Excel or HTML.

### Input fields

`domains` takes domains or full URLs; `datasetId` reads the website column of an earlier run instead, and `datasetField` names that column if it is not detected. `jobKeywords` keeps only positions whose title or department contains one of the words. `onlyHiring` drops companies without positions from the table. `onlyNewJobs` returns only positions that are new since the last run, with the memory kept under `seenStoreName`. `maxDomains`, `maxJobsPerCompany` and `maxPagesPerDomain` cap the work, `compact` returns short rows for AI agents, and `maxConcurrency` and `maxRunTimeSecs` control speed and duration.

### Use it from an AI agent (MCP)

The Actor works as a tool for Claude, ChatGPT, Cursor and other MCP clients through the Apify MCP server: `https://mcp.apify.com/?tools=berkaydev/company-hiring-signals`. Agents can send `{"domains": [...], "compact": true}` and read `hiring`, `jobCount` and `jobTitles` directly. Field names such as `urls`, `websites` or `companies` are accepted as well.

### Pricing

You pay per company with at least one open position found. Companies without positions, websites that do not answer, and status rows are free. Small runs finish in seconds: 64 companies took about 20 seconds in testing.

### Limits, said plainly

Career pages that load their job list only with JavaScript cannot be read; the row then says that a career page exists but no position could be read. The title detection relies on the gender marker that German-language job ads carry, so for English-only sites without an ATS feed or JobPosting data fewer positions are found. The Actor reads only pages the company publishes itself and the official public job feeds of ATS providers; it does not log in anywhere and does not use job boards such as Indeed or StepStone. It returns no names or contact details of recruiters.

### FAQ

**How does it know a company is hiring?** It opens the company website, finds the career page and reads open positions from the ATS job feed, from JobPosting data on the page, or from job titles such as "Vertriebsmitarbeiter (m/w/d)".

**Which applicant tracking systems are supported?** Jobs are read from the public feeds of Personio, Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee. Softgarden, Workday, SuccessFactors, d.vinci, rexx, onlyfy, JOIN, Teamtailor and BambooHR are recognised and named in the `ats` field.

**Can I get only companies that started hiring this week?** Yes. Turn on `onlyNewJobs` and schedule the run weekly with the same company list; only companies with new positions come back and are charged.

**Can I check the businesses from a Google Maps search?** Yes. Pass the dataset ID of the Google Maps Email Scraper run as `datasetId`; the website column is found automatically.

**Does it work outside Germany?** Yes for ATS feeds and JobPosting data worldwide. The title detection is strongest on German, Austrian and Swiss sites, where job titles carry "(m/w/d)".

**Why does a company show hiring = null?** No career page or job link was found on its website. Many small businesses simply do not publish jobs online.

**Is this legal to use?** The Actor reads public pages the companies publish to attract applicants, and the ATS feeds that exist so job posts can be shown elsewhere. It collects no personal data. How you use the results, for example for outreach, is governed by the rules where you operate, such as the GDPR and, in Germany, the UWG.

# Actor input Schema

## `domains` (type: `array`):

Domains or website URLs of the companies to check, e.g. delker.com or https://www.gundlach-packaging.com. One row per company comes back.

## `datasetId` (type: `string`):

Chain Actors: pick or paste the dataset ID of an earlier run, for example from Google Maps Email Scraper or Company Email Finder. The website column is detected automatically. Pass it in this field (datasetId) so the Actor is allowed to read it.

## `datasetField` (type: `string`):

Only needed if the website column is not detected automatically, e.g. companyWebsite.

## `jobKeywords` (type: `array`):

Keep only positions whose title or department contains one of these words (case-insensitive), e.g. sales, Vertrieb, Lager, engineer. A company counts as hiring only if a matching position is open.

## `onlyHiring` (type: `boolean`):

Leave out companies without open positions. They are free either way; this just keeps the table short.

## `onlyNewJobs` (type: `boolean`):

Remembers the positions each company had in earlier runs and returns only ones that are new. Schedule it weekly to see which companies just started hiring. Only companies with new positions are charged.

## `checkSalary` (type: `boolean`):

Open each job ad and record whether it states a salary (amount or range) or a collective agreement (Tarif, TVöD …), as the EU Pay Transparency Directive will require. Adds one page per job, up to maxSalaryChecksPerCompany.

## `maxSalaryChecksPerCompany` (type: `integer`):

How many job ads per company are opened when checkSalary is on.

## `seenStoreName` (type: `string`):

Named key-value store in your account that keeps the memory. Use a different name per company list if you track several lists.

## `maxDomains` (type: `integer`):

Stop after this many companies (0 = all).

## `maxJobsPerCompany` (type: `integer`):

Large employers can have hundreds of openings; this caps the list per row.

## `maxPagesPerDomain` (type: `integer`):

How many career-related pages are opened per company besides the homepage.

## `compact` (type: `boolean`):

Return only domain, hiring, jobCount, jobTitles, ats, careerPage and statusNote.

## `maxConcurrency` (type: `integer`):

How many companies are checked at the same time.

## `maxRunTimeSecs` (type: `integer`):

The run stops cleanly before this and keeps everything found so far.

## Actor input object example

```json
{
  "domains": [
    "delker.com",
    "gundlach-packaging.com",
    "n8n.io"
  ],
  "onlyHiring": false,
  "onlyNewJobs": false,
  "checkSalary": false,
  "maxSalaryChecksPerCompany": 10,
  "seenStoreName": "hiring-signals-seen",
  "maxDomains": 0,
  "maxJobsPerCompany": 100,
  "maxPagesPerDomain": 4,
  "compact": false,
  "maxConcurrency": 10,
  "maxRunTimeSecs": 3000
}
```

# Actor output Schema

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

One row per company: hiring yes/no, open positions, job titles, career page and ATS.

## `runStatus` (type: `string`):

Companies checked, how many are hiring, open positions, ATS seen and the reason for an empty run.

# 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 = {
    "domains": [
        "delker.com",
        "gundlach-packaging.com",
        "n8n.io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("berkaydev/company-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 = { "domains": [
        "delker.com",
        "gundlach-packaging.com",
        "n8n.io",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("berkaydev/company-hiring-signals").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 '{
  "domains": [
    "delker.com",
    "gundlach-packaging.com",
    "n8n.io"
  ]
}' |
apify call berkaydev/company-hiring-signals --silent --output-dataset

```

## MCP server setup

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

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/pjCTTU4Z5pPxsg2tE/builds/eXiujNMHdlwqvFBhN/openapi.json
