# Companies Hiring Now 🏢 (checked in the company register) (`tagadanar/verified-hiring-employers`) Actor

Find the companies hiring for a role in a city, or check your own account list, and get one row per employer: open postings, the registered legal entity (SIREN, UK company number, HRB), still trading or in insolvency, a recruitment-agency flag and a scored match. France, UK, Germany. No API key.

- **URL**: https://apify.com/tagadanar/verified-hiring-employers.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.50 / 1,000 employer verifieds

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

## Companies Hiring Now 🏢 (checked in the company register)

Hiring lists tell you a name on a job card. This one tells you the company.

Every employer that comes back has been looked up in its own national company
register: the registration number, the legal form, when it was incorporated,
whether it is still trading, and whether a court has opened an insolvency
procedure against it. France, the United Kingdom and Germany, from the official
sources, with no API key and no proxy to configure.

You get one row per **employer**, not one row per job. A row is worth something
because a salesperson or a recruiter can act on it straight away: here is who
is hiring, here is what for, here is the registered entity behind it, and here
is a score with its reasoning written out.

### Where this sits

Hiring signals are the classic reason people buy a sales-intelligence seat.
LinkedIn Sales Navigator is $119.99 per seat per month for Core and $159.99 for
Advanced, ZoomInfo will not publish a price at all, and both are annual seats
you keep paying for whether you pull a list this month or not. This actor does
one slice of that job, on demand, per row, and adds the piece neither of them
puts on the row: the registered legal entity behind the posting.

The Store has both halves of this product separately, and nobody joins them.
Prices and features below are what each actor's own Store page said on
17 August 2026.

| | One row per | Register number and status | Insolvency check | Agency flag | Price |
| --- | --- | --- | --- | --- | --- |
| **This actor** | employer | SIREN, UK company number, HRB | BODACC, The Gazette, Insolvenzbekanntmachungen | yes | flat per employer, misses free, usage included |
| `apivault_labs/apify-actor-job-leads` | job posting | no | no | no | $3.00 per 1,000 rows |
| `alizarin_refrigerator-owner/linkedin-jobs-scraper-b2b-hiring-intent-signals` | job posting | no | no | no | $0.10 per run plus $10 per 1,000 jobs |
| `jy-labs/ats-hiring-signal-radar` | company scanned | no | no | no | $20 per 1,000 companies |
| Single-country register scrapers (Companies House, KVK, Northdata and friends) | company | one country each | usually not | no | from $2 per 1,000 companies |

A job-row actor bills you once per posting, so a company advertising forty roles
costs you forty rows and still leaves you without a registration number. Here
that company is one row, with the number on it.

### Two ways to use it

**Find who is hiring.** Give it search terms and a place ("sales manager" in
Paris, "Pflegefachkraft" in Berlin, "account manager" in London). It reads the
public job postings, folds them into distinct employers, and checks each one.

**Check a list you already have.** Give it your target accounts by name,
website or careers board URL. It looks for their own Greenhouse, Lever, Ashby,
SmartRecruiters or Workable board, counts what is open, and runs the same
company check.

### What you get

| Field | What it is |
| --- | --- |
| `employerName` | The company as the postings name it |
| `verdict` | One sentence you can read in a spreadsheet cell |
| `confidence` / `confidenceBand` | 0-100, and verified / likely / uncertain / unverified |
| `confidenceReasons` | Every point that went into the score, in words |
| `hiringStatus` | actively-hiring, hiring-slowing, hiring-stale, no-open-postings |
| `openPostings`, `newestPostingDate`, `postingRecencyDays` | How much and how fresh |
| `postingTitles`, `postingLocations` | What they are hiring for and where |
| `careersBoardUrl` | Their own careers board, when one was found |
| `legalName`, `registryId`, `registryIdType` | SIREN, UK company number or HRB |
| `legalForm`, `activityCode`, `incorporationDate` | The register's own facts |
| `companyStatus`, `dissolutionDate` | Active, ceased, dissolved, in insolvency |
| `insolvencyStatus`, `insolvencyHits` | BODACC, The Gazette or Insolvenzbekanntmachungen, with links |
| `officers`, `employeesRange`, `registeredAddress` | Directors, headcount band, registered office |
| `likelyRecruitmentAgency` | True when this is an agency posting for a client |
| `matchScore`, `matchType`, `matchedOnName` | How the name was matched, and to which registered name |
| `matchAlternatives` | The runners-up, so an ambiguous match is visible |
| `riskFlags` | insolvency, closed, recruitment-agency, short-name-match, hiring-stale |
| `registryUrl` | Straight to the register entry |

Full field list with examples is on the Output tab.

### Who this is for

**B2B sales targeting companies that are growing.** A company posting five new
roles is spending money. Sorting your prospect list by `hiringStatus` and
`openPostings` puts the ones with a budget at the top, and `insolvencyStatus`
takes the ones about to go under off it. The registration number means the row
drops into a CRM next to everything else you know about that account.

**Recruiters and staffing agencies.** You want the company that is hiring, not
the four agencies advertising the same role. `likelyRecruitmentAgency` is set
from the register's own activity code where the register has one (NAF 78.xx in
France, SIC 781xx/782xx/783xx in the UK), and from the company name otherwise,
and the row says which of the two it used.

**Anyone building a hiring-signal feed.** Run it on a schedule with
`postedSince` set to the last 24 hours and you get a daily list of newly hiring,
verified companies. `newestPostingDate` and `postingRecencyDays` make "started
hiring this week" a filter rather than a guess.

**Credit and risk teams.** A company can be hiring and in a collective
procedure at the same time. That combination shows up here as
`hiringStatus: actively-hiring` with `riskFlags: ["insolvency"]`, linked to the
official notice.

### Coverage, stated plainly

The company registers covered are **France (SIRENE and the RNE), the United
Kingdom (Companies House) and Germany (the Handelsregister)**.

An employer hiring outside those three still comes back, with its postings, and
carries `registryStatus: "country-not-covered"` and a verdict that names the
country. **Those rows are not billed.** Nothing is ever dropped without saying
so, because a list that quietly loses half its rows is worse than a short list.

The country comes from the postings' own locations, so searching Paris, London
or Berlin is what produces verified rows. If your postings do not say (a
remote-only role, for instance), the `country` setting decides.

### Example input

Find who is hiring:

```json
{
  "keywords": ["sales manager", "account executive"],
  "location": ["Paris"],
  "postedSince": "month",
  "maxEmployers": 50
}
```

Check an account list you already have:

```json
{
  "employers": [
    "Doctolib",
    "monzo.com",
    "Zalando Logistics GmbH",
    "https://jobs.lever.co/spotify"
  ],
  "maxEmployers": 25
}
```

A list piped in from another scraper, keeping the towns so the register match
is tighter:

```json
{
  "employers": [
    { "companyName": "Decathlon France", "city": "Villeneuve-d'Ascq", "country": "FR" },
    { "companyName": "Marks and Spencer Group plc", "country": "GB" }
  ],
  "checkInsolvency": true,
  "minMatchScore": 88
}
```

### How the matching works, and where it stops

A job card carries a brand name. A register carries a legal name. Getting from
one to the other is the whole product, so the actor shows its work rather than
handing you a yes or no.

The name match runs a ladder from an exact legal-name hit down to a fuzzy one,
and every row reports which rung it landed on in `matchType`. Location evidence
from the posting nudges the score: agreeing with the registered office town
adds points, disagreeing takes more away, because "same name, different town"
is the commonest wrong answer on a national register.

Three things deliberately do not happen:

Very short brand names do not buy identity on their own. A three or four letter
name will exact-match some unrelated company on any national register, so a
match on a short name is capped and flagged with `short-name-match` unless the
posting's own town confirms the registered address.

When two companies score within a few points of each other, the result is
`ambiguous` rather than a coin flip, the score is cut, and the runners-up ship
in `matchAlternatives` so you can look.

An employer with no clear country is not routed to a register at random. It
comes back as `country-unknown`, unbilled, with a note saying what to set.

### Pricing

You pay per employer the register actually answered on, whether the answer was
a match or a "not in the register" (both are useful, and the second one is
often the more useful). Employers in countries we do not cover, and employers
whose register could not be reached, ship with `billed: false` and cost you
nothing beyond the run fee.

Platform usage is included in the price. There is no proxy to buy and no API
key to bring.

### Sources

- Job postings: LinkedIn's public jobs pages, and the public job-board APIs of
  Greenhouse, Lever, Ashby, SmartRecruiters and Workable.
- France: `recherche-entreprises.api.gouv.fr` (INSEE SIRENE and INPI RNE) and
  BODACC for collective procedures.
- United Kingdom: the public Companies House company search, plus The Gazette
  for insolvency notices. Bring your own free Companies House API key if you
  want SIC codes and richer status data.
- Germany: the Registerportal on handelsregister.de and the state justice
  portal Insolvenzbekanntmachungen.

Everything here is company data from official registers and public job
listings. No named individual is scraped from a social profile.

### Works well with

- [ATS Jobs Aggregator](https://apify.com/tagadanar/ats-jobs-aggregator) when
  you want every job from a company's Greenhouse, Lever, Ashby, SmartRecruiters
  or Workable board rather than one row about the company.
- [LinkedIn Jobs Scraper](https://apify.com/tagadanar/linkedin-jobs-scraper)
  when you want the postings themselves, with full descriptions and applicant
  counts.
- [B2B Lead Verifier](https://apify.com/tagadanar/b2b-lead-verifier) when the
  list you are checking is not about hiring at all: same registers, plus a
  sanctions screen against the OFAC, UN, EU and UK lists.
- [French Company KYC](https://apify.com/tagadanar/french-company-kyc),
  [Companies House Monitor](https://apify.com/tagadanar/companies-house-monitor)
  and [German Company KYC](https://apify.com/tagadanar/german-company-kyc) when
  you already know exactly which company you want.

A good chain: run this to find verified hiring employers, then feed
`employerName` into ATS Jobs Aggregator to pull every open role at the ones
worth pursuing.

### FAQ

**How do I find companies that are hiring right now?**
Put what they are hiring for in `keywords` and where in `location`, set
`postedSince` to the last week or the last 24 hours, and every employer that
comes back has a posting inside that window with its date attached.

**Can I check whether a company is still trading before I contact it?**
Yes. `companyStatus` comes from the register and `insolvencyStatus` from the
official insolvency source for that country, with links to the notices in
`insolvencyHits`.

**How do I get the SIREN or the company number for a company that is hiring?**
It is in `registryId`, with `registryIdType` saying which kind of number it is
and `registryUrl` linking to the register entry.

**How do I filter out recruitment agencies from a hiring list?**
Drop the rows where `likelyRecruitmentAgency` is true. `agencySignal` tells you
whether that came from the register's activity code, which is solid, or from
the company name, which is a good guess.

**Does this work for companies in the United States?**
It finds them and reports their postings, but it cannot verify them: no US
register is covered, so those rows come back as `country-not-covered` and are
not billed. Search a French, British or German location for verified rows.

**Do I need a LinkedIn account or a Companies House API key?**
No to both. Everything runs off public endpoints. A Companies House key is
optional and only improves the UK data.

**Why does an employer show as "not found in the company register"?**
Usually the posting carries a trading name that is not the registered name, or
the hiring entity is a foreign parent with no local registration. The row keeps
the hiring evidence either way, and raising or lowering `minMatchScore` changes
how strict the matching is.

**Can I run it as a daily hiring-signal monitor?**
Yes. Schedule it with `postedSince` set to the last 24 hours. Each run gives
you the employers that posted since yesterday, already checked against their
register.

**What does the confidence score actually mean?**
How sure we are that the company named in the row is the real, currently
trading entity behind those postings. It is identity out of 60, still-trading
out of 30, and address corroboration out of 10, and `confidenceReasons` lists
every point.

***

Keywords: verified hiring employers, hiring companies with legal entity,
hiring signals verified, companies hiring now, job postings company register,
hiring intent data, B2B hiring signals, employer verification, SIREN lookup
hiring, Companies House hiring, Handelsregister hiring, recruitment agency
filter, growth signals prospecting, ATS job board scraper, LinkedIn hiring
signal, company insolvency check, France UK Germany company register.

# Actor input Schema

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

What the people they are hiring do, exactly as you would type it into a jobs search box: <code>sales manager</code>, <code>data engineer</code>, <code>infirmier</code>. Every term is run against every location below, and the employers behind the postings are what you get back. Leave this empty if you already have a company list and want to use the "Companies to check" field instead.

## `location` (type: `array`):

City, region or country to search in: <code>Paris</code>, <code>London</code>, <code>Berlin</code>, <code>France</code>. The company registers covered are French, British and German, so a search inside those three countries is what produces verified rows. Employers found elsewhere are still returned, marked as not covered, and are not billed.

## `employers` (type: `array`):

Use this when you already have target accounts. One entry per company: a name (<code>Doctolib</code>), a website (<code>monzo.com</code>), or a careers board URL (<code>https://jobs.lever.co/spotify</code>). Each one is checked for open postings on its own careers board first, then on LinkedIn, then against its national company register. Rows piped in from another actor's dataset work too.

## `postedSince` (type: `string`):

How fresh a posting has to be to count as a hiring signal. Shorter windows give a smaller, hotter list.

## `maxEmployers` (type: `integer`):

Stop after this many distinct employers. You are billed per employer the register answered on, so this is your budget.

## `country` (type: `string`):

Most postings name their country, and that always wins. This is the fallback for the ones that do not (a remote-only posting, for instance).

## `checkInsolvency` (type: `boolean`):

Also look each matched company up in BODACC (France), The Gazette (UK) or Insolvenzbekanntmachungen (Germany). A company can be hiring and in a collective procedure at the same time, which is exactly what you want to know before signing one. Slower, and free.

## `minMatchScore` (type: `integer`):

How close a registered legal name has to be to the employer name on the posting before we call it a match, from 70 (loose) to 100 (exact only). Raise it if you would rather have gaps than wrong companies.

## `companiesHouseApiKey` (type: `string`):

UK employers are checked against the free public Companies House search by default, no key needed. Supply your own free key from developer.company-information.service.gov.uk to get SIC codes and richer status data instead.

## Actor input object example

```json
{
  "keywords": [
    "sales manager"
  ],
  "location": [
    "Paris"
  ],
  "postedSince": "month",
  "maxEmployers": 5,
  "country": "",
  "checkInsolvency": true,
  "minMatchScore": 82
}
```

# Actor output Schema

## `employers` (type: `string`):

One row per employer: hiring evidence, the registered company behind it, insolvency status and a confidence score.

# 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": [
        "sales manager"
    ],
    "location": [
        "Paris"
    ],
    "maxEmployers": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/verified-hiring-employers").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": ["sales manager"],
    "location": ["Paris"],
    "maxEmployers": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/verified-hiring-employers").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": [
    "sales manager"
  ],
  "location": [
    "Paris"
  ],
  "maxEmployers": 5
}' |
apify call tagadanar/verified-hiring-employers --silent --output-dataset

```

## MCP server setup

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

```

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/l9VyrbuCXQ2p9z1ND/builds/BSEgKjkKWRsdCgzWS/openapi.json