# Company Jobs – Greenhouse, Lever, Ashby, Personio, Recruitee (`extractlyspace/company-jobs-scraper`) Actor

Get current job openings for a list of companies, read live from their hiring systems: Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee and Personio. Returns title, department, location, remote flag, posted date, salary when published and apply link. No login needed.

- **URL**: https://apify.com/extractlyspace/company-jobs-scraper.md
- **Developed by:** [Spase Nikolov](https://apify.com/extractlyspace) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 jobs

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?

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

## Company Jobs – Greenhouse, Lever, Ashby, Personio, Recruitee

This Actor returns the current job openings of the companies you give it, read live at run time from the hiring systems they use: Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee and Personio. Each row has the job title, department, location, remote flag, posting date and apply link, plus salary when the company publishes it and the job description as plain text (up to 20,000 characters) if you ask for it. When a company's own website carries job postings in its page markup (schema.org JobPosting), the Actor reads those as a fallback. No login is needed.

**Workday:** since 17 November 2026, Workday answers automated requests to its career sites with a bot check. A Workday career site gets an `unsupported` row that says so, and the other companies in the run are read as usual. It works again by itself if Workday lifts the check.

### Use this to

- **Use hiring as a buying signal**: see which companies are hiring for roles that point to a need for your product, such as data engineers or security staff.
- **Search for jobs** across a list of companies you like, filtered by title words, place, remote work and how recently the job was posted.
- **Research recruiting competitors and talent markets** by seeing which roles a set of companies has open and where.
- **Monitor companies for new openings** by scheduling a run with `onlyNew` turned on, for example as an investor watching a portfolio.

### Sample output

| recordType | company | title | department | location | isRemote | postedAt | source | salaryMax |
|---|---|---|---|---|---|---|---|---|
| job | Example Co | Senior Backend Engineer | Engineering | Berlin, Germany | false | 2026-11-09T08:00:00.000Z | greenhouse | null |
| job | Sample Labs | Product Designer | Design | Remote (US) | true | 2026-11-03T14:20:00.000Z | ashby | 180000 |

These values are invented for illustration. Every job row has the same 19 fields: `recordType`, `company`, `companyDomain`, `title`, `department`, `location`, `country`, `isRemote`, `employmentType`, `postedAt`, `applyUrl`, `jobId`, `source`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `description` and `scrapedAt`. A value the hiring system does not provide is returned as `null`. `source` names where the job was read from: one of the eight systems, or `jsonld` for a company's own website. `company` is the job board's own company name when it gives one; for jobs read from a company website it is the hiring organization the page states, or the domain. If a company's page links to another organization's job board, such as a staffing agency's or a parent company's, that board is what is returned, and `company` shows that organization's name. `companyDomain` is filled only when you gave a domain or a website URL. `description` is `null` unless you turn on `includeDescription`.

### Pricing

You pay per event:

- `job`: $0.0015 for each job returned.
- `job-description`: $0.001 more for each job that has a description, only when `includeDescription` is on. A job returned with its description therefore costs $0.0025.

Examples: 3 companies at 50 jobs each cost at most $0.23. 100 jobs with descriptions cost at most $0.25.

Explanatory rows (see below) are never charged. The run stops when it reaches your spending limit.

### Input

- **companies**: required. Website domains, careers page URLs, job board URLs or company names, up to 100 per run. A job board URL is read as given. A domain or careers page is matched through the company's own website: the job board its pages link to is used. A board found only because its name matches the domain is used when it, and no other board of the same name, points back to that domain (a job on its first page applies there, or the board's own page names the domain); otherwise, when the site has no job postings of its own either, you get one free row that suggests the board's URL to confirm, and no jobs. A plain name is matched by the board's own company name. If more than one such board has open jobs, the run returns one free row that lists them with their URLs, and you send one of those URLs. Workday cannot be found from a name; it is found from its job board URL, such as `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`, or when the company's careers page links to it. Greenhouse EU boards (`boards.eu.greenhouse.io`, `job-boards.eu.greenhouse.io`) are not supported yet.
- **keywords**: only jobs whose title contains one of these words, ignoring case.
- **locations**: only jobs in one of these places. A country, by code or name (such as `US`, `DE` or `Germany`), matches the job's country; when the hiring system gives no country, it matches the country's name or a common abbreviation (US, USA, UK) as whole words in the location text. A Greenhouse job whose location names only a city, such as `Berlin`, is therefore not matched by `Germany`. So a country name matches whole words of the location text when a system gives no country: `Georgia` also matches "Atlanta, Georgia" there. Any other entry, such as a city, matches whole words in the location text, ignoring case; `remote` also matches jobs marked as remote.
- **remoteOnly**: only jobs marked as remote (default off). Jobs whose remote status is unknown are left out.
- **postedWithinDays**: only jobs posted in the last N days, 1 to 365. Jobs without a posting date are left out when this is set.
- **maxJobsPerCompany**: the most jobs to return for each company, 1 to 1000 (default 50). Each returned job is charged. Filters apply before this limit. Systems that return a whole board at once (all except SmartRecruiters and Workday) give the newest jobs first. SmartRecruiters and Workday are read page by page, so you get the newest among the jobs read before the limit was reached. Jobs without a date come last.
- **includeDescription**: adds the job description as plain text, up to 20,000 characters (default off). It is charged as an add-on for each job that has one. SmartRecruiters and Workday need one extra request per job, so descriptions are slower there; when the time allowed for a company runs out, its remaining jobs are returned without descriptions and without the add-on charge, with a `partial` row that says how many were described. If descriptions cannot be read for a company, its jobs are returned without them and without the add-on charge, with a `partial` row.
- **onlyNew**: returns only jobs this Actor has not returned to you before for the same job board (default off).

The same job board named twice in one run is delivered once, however it was named (one Personio account given on `.de` and on `.com` is one board); the second mention gets a free row that points to the first.

For a domain or careers page the Actor decides in this order: a job board the company's own pages link to; the one board found by its name that points back to the domain; then the site itself. There, an address that does not exist or a page that answers "not found" gets a free row saying so; otherwise the site's own job postings are returned, and when it has none, a free row says what was found (a board to confirm, or several to choose from) or which hiring systems could not be checked. For a page on another company's site, such as a directory or profile page (`ycombinator.com/companies/acme`), the name of that site is what is matched, not the company the page is about, unless the page itself links a job board, in which case that board is read: send the company's own domain instead.

### What each system provides

| System | Department | Country | Remote flag | Employment type | Posting date | Description | Salary |
|---|---|---|---|---|---|---|---|
| Greenhouse | yes | no | only when the location says "remote" | no | yes | in the same request | no |
| Lever | yes | yes | yes | yes | yes | in the same request | when published |
| Ashby | yes | yes | yes | yes | yes | in the same request | when published |
| Workable | yes | yes | yes | yes | yes | in the same request | no |
| SmartRecruiters | yes | yes | yes | yes | yes | one extra request per job | no |
| Recruitee | yes | yes | yes | yes | yes | in the same request | when published |
| Personio | yes | no | only when the location says "remote" | yes | yes | in the same request | when published |
| Workday | no | with descriptions only | no | with descriptions only | approximate; exact with descriptions | one extra request per job | no |

Among the eight hiring systems, salary comes only from Ashby, Lever, Recruitee and Personio, and only when the company publishes it. Jobs read from a company's own website (`jsonld`) carry a salary when the page states one, and otherwise whatever the page's JobPosting markup gives. `salaryPeriod` is `year`, `month`, `week`, `day` or `hour` when the period is recognized; an unrecognized period is passed through in lower case. Workday lists a posting date only as "posted N days ago"; the Actor turns that into a date, leaves it `null` for vaguer texts such as "30+ days", and reads the exact posting date from the job itself only when `includeDescription` is on. The extra request per job makes descriptions slower on SmartRecruiters and Workday. Fields marked "yes" can still be `null` on a given job when the company leaves them out.

### What you get when nothing matches

An input the form itself rejects, such as a missing `companies` or a text where a list belongs, is refused before the run starts. When nothing matches or the input needs correcting in another way, such as an address that does not exist or a page that answers "not found", the run succeeds and returns a short explanatory row instead of an empty result. The run fails, with a clear message, only when hiring systems or websites could not be read and nothing was returned. If only some companies or jobs could be read, you get what was read plus a `partial` row for each part that could not. The explanatory row has `recordType: "status"`, a `message` in plain language and a `subject` naming what it refers to. The `status` is one of:

- `no_results`: the board was found but lists no open jobs, no job matches the filters, nothing new appeared since the last run, or the company is the same job board as an earlier entry.
- `invalid_input`: the input passed the form but could not be used, for example an empty list of companies or more than 100 companies.
- `not_found`: no job board or job postings were found for the entry, no website answers at the address or its page answers "not found", a job board URL does not exist, a name matches more than one job board (the row lists them), or a board found only by its name could not be confirmed for the domain (the row suggests it).
- `unsupported`: the entry is not a company's own website (such as a LinkedIn, X or GitHub page), is not a public web address, or is a job board this Actor cannot read yet (Greenhouse EU).
- `partial`: a company could not be read right now, some hiring systems could not be checked for a name or domain, the board stopped answering part-way, descriptions could not be read or ran out of time, or only the first jobs of a very large board were read.
- `limit_reached`: the run stopped at your spending limit.

### What it never returns

No recruiter, hiring-manager or contact fields are used or returned, and nothing about applicants is returned. The description is the posting's own text as the company published it, with email addresses and clearly formatted phone numbers removed; it may still mention people the company chose to name.

### FAQ

**How fresh is the data?** Jobs are read live from the hiring system when the run happens. The Actor does not keep its own copy and does not promise a complete list of every job a company has.

**Do I need an account with any hiring system?** No. The Actor reads only public job boards and public company pages.

**How does `onlyNew` remember jobs?** The Actor stores the IDs of jobs it has returned in a key-value store named `company-jobs-scraper-seen` in your own Apify account, separately for each job board. A later run for the same board skips them.

This Actor reports usage statistics to its developer to keep it reliable: the Actor's name and build number, the time of the run, the run's outcome, row counts, events charged, an estimate of the revenue from those events, an estimate of what paid data sources cost for the run (always zero for this Actor), duration, a short error category when a run fails, partly fails or meets upstream data in an unexpected shape, how the run was started, whether the account is on a paid plan, and a one-way hash of the Apify user ID. It never reports your inputs or the data returned.

# Actor input Schema

## `companies` (type: `array`):

Companies to get job openings for: website domains, careers page URLs, job board URLs or names, for example \["stripe.com", "https://jobs.lever.co/spotify", "Figma"]. Up to 100. A domain is matched through the company's own website; a name by the job board's company name.

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

Only jobs whose title contains one of these words, for example \["engineer", "designer"]. Leave empty for all jobs.

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

Only jobs in these places: countries (code or name), cities or "remote", for example \["US", "Berlin", "remote"]. A country matches the job's country, else whole words of its location text. Leave empty for all locations.

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

Return only jobs marked as remote. Example: true

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

Only jobs posted in the last N days, from 1 to 365. Example: 7 for the last week. Leave empty for all open jobs.

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

The most jobs to return for each company, from 1 to 1000, newest first where the system allows. Each returned job is charged. Example: 50

## `includeDescription` (type: `boolean`):

Add the job description as plain text, up to 20,000 characters. Charged as an add-on for each job that has one, and slower for some hiring systems. Example: true

## `onlyNew` (type: `boolean`):

Return only jobs this Actor has not returned to you before for the same job board. Use it for scheduled monitoring. Example: true

## Actor input object example

```json
{
  "companies": [
    "stripe.com"
  ],
  "keywords": [],
  "locations": [],
  "remoteOnly": false,
  "maxJobsPerCompany": 5,
  "includeDescription": false,
  "onlyNew": false
}
```

# Actor output Schema

## `jobs` (type: `string`):

One row per open job (recordType "job"). A company that could not be matched or read, and a run that could return nothing, give an explanatory row instead (recordType "status", with status, message and subject).

# 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 = {
    "companies": [
        "stripe.com"
    ],
    "maxJobsPerCompany": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractlyspace/company-jobs-scraper").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 = {
    "companies": ["stripe.com"],
    "maxJobsPerCompany": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("extractlyspace/company-jobs-scraper").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 '{
  "companies": [
    "stripe.com"
  ],
  "maxJobsPerCompany": 5
}' |
apify call extractlyspace/company-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/11fetysfVMxHKey6a/builds/VUdcZskXxmojPuZc0/openapi.json
