# Company Careers Jobs API: Greenhouse, Lever, Ashby + 7 ATS (`sandy_cornfield/company-jobs-api`) Actor

Get every open job from companies' own careers boards on 10 ATS (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio, Teamtailor, Gem, Breezy) in one clean format. Paste a careers page or board URL. Only-new mode. Optional AI fields: visa sponsorship, salary, seniority, skills.

- **URL**: https://apify.com/sandy_cornfield/company-jobs-api.md
- **Developed by:** [Careers Data Lab](https://apify.com/sandy_cornfield) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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 Careers Jobs API: Greenhouse, Lever, Ashby, Workable and 6 more ATS

Get every open job straight from companies' own careers boards, in one clean format, without scraping job sites.

This Actor reads the **public job-board feeds** that ten ATS vendors provide for career sites, embedding and job syndication: Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee, Workable, Personio, Teamtailor, Gem and Breezy HR. No browser, no proxies, no logins, so it is fast, cheap and does not break when a website changes its layout.

### What you get

- **Paste the careers page, get the jobs.** Give the company's own careers page and the Actor finds the ATS board behind it (links, iframes, embed scripts; for JavaScript-only pages it tries the company name from the domain, uses it only when exactly one ATS answers, marks those jobs with `matchedBy: "domain-name"` and says so in the log, because a different company can use the same name).
- **One format for ten ATS.** Title, department, team, employment type, seniority (when the ATS has it), all locations, workplace type (remote / hybrid / onsite), posted and updated dates in UTC, job page and apply links, and salary when the employer publishes it.
- **Only new jobs.** Switch on *Only new jobs since the last run* and schedule the Actor: each run returns only postings you have not received before.
- **Filters and limits.** Title keywords, excluded keywords, locations, workplace types, "posted in the last N days", a total cap and a per-company cap so one big board does not crowd out the rest.
- **Full descriptions (optional)** as plain text, with free keyword flags for visa sponsorship and relocation.
- **Typed signals** on jobs with a description: visa sponsorship, relocation support, workplace type and seniority, each with a confidence score. Free.
- **AI fields (optional, charged separately):** visa sponsorship yes/no/unknown *with the exact quote*, relocation support, remote regions ("Remote (US)" → US), normalised salary range, currency and period, seniority, minimum years of experience, skills and required languages. A failed enrichment is never charged.

### Input

| Field | Example |
|---|---|
| Companies | the company's own careers page (`https://www.figma.com/careers/`), an ATS board URL (`https://jobs.lever.co/spotify`), `ats:slug` such as `greenhouse:airbnb` or `workable:huggingface`, or just `notion` to try all ten ATS |
| Title keywords | `engineer`, `data` |
| Locations | `London`, `Dubai`, `Remote` |
| Workplace types | `remote`, `hybrid` |
| Posted within (days) | `7` |

**Finding a company's board:** open its careers page and look at a job link. `boards.greenhouse.io/<slug>`, `jobs.lever.co/<slug>`, `jobs.ashbyhq.com/<slug>`, `jobs.smartrecruiters.com/<slug>`, `<slug>.recruitee.com`, `apply.workable.com/<slug>`, `<slug>.jobs.personio.de`, `<slug>.teamtailor.com`, `jobs.gem.com/<slug>` and `<slug>.breezy.hr` all work as input as they are. Teamtailor sites on their own domain: `teamtailor:careers.example.com`. Not sure? Enter the company name as a single word and the Actor checks all ten at once.

### Output (one item per job)

```json
{
  "id": "ashby:ramp:34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "ats": "ashby",
  "companySlug": "ramp",
  "title": "Security Engineer, Cloud",
  "department": "Engineering",
  "team": "Backend",
  "employmentType": "FullTime",
  "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
  "workplaceType": "hybrid",
  "postedAt": "2026-04-07T17:12:35Z",
  "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "salary": {"min": 211400, "max": 290600, "currency": "USD", "period": "year", "source": "ats"}
}
```

With AI fields switched on, each item also carries an `ai` object with the fields listed above.

### Pricing

Pay per result: you are charged per job delivered, and AI fields are a separate per-job event that you switch on only when you need them. Set a maximum cost per run in the run options and the Actor stops cleanly at that limit; jobs it did not deliver stay "new" for your next run.

### Use cases

- Job boards and newsletters that list jobs from a fixed set of companies
- Recruiting and sales teams watching who is hiring for which roles
- Market and salary research from employers' own published ranges
- Candidates and relocation services filtering for visa sponsorship and remote regions
- AI agents that need fresh, structured job data (works through the Apify MCP server)

### Data and compliance

The Actor reads the vendors' public job-board feeds (documented APIs, XML and RSS feeds, and the feeds behind their embeddable job widgets) and, when you give one, the company's own public careers page to find its board. Requests are polite, with no login and no workaround of any access control; private and internal network addresses are refused. The output contains what employers publish for candidates. Recruiter names, emails and phone numbers are not extracted as fields. Descriptions are the employer's own text and may include a contact address the employer chose to publish.

### Messages in the run log and what to do

| Message | What it means | What to do |
|---|---|---|
| `no public job board found on greenhouse, lever, ...` | The slug is not used on any of the ten ATS | Open one job on the company's careers page and paste that job's URL, or the careers page itself |
| `no supported job board found on this page` | The careers page loads its jobs with JavaScript or uses an ATS this Actor does not read (Workday, BambooHR, iCIMS, Taleo ...) | Paste the URL of one job; if it is on one of the ten ATS it will work |
| `matched by the domain name '<name>' on <ats>, please check the company` | No board link on the page, so the company name in the domain was tried and exactly one ATS answered. Jobs carry `matchedBy: "domain-name"` | Check one job; if it is the wrong company, use the exact board URL instead |
| `'<name>' exists on several ATS` | The domain name matches boards on more than one ATS, so nothing was guessed | Add the right one as `ats:<name>`, for example `ashby:acme` |
| `this site is not a supported careers page` | You pasted a job site or an unsupported ATS (LinkedIn, Indeed, Workday ...) | Use the company's board on one of the ten ATS |
| `not a public web page` / `not a public address` | The URL points to a private or local address | Use a public URL |
| `HTTP 429` / `HTTP 5xx` | The ATS was busy; the Actor already retried | Run again later; with **Only new jobs** on, nothing is lost or charged twice |
| `Stopped at your maximum cost per run` | Your cost limit was reached | Raise the limit or narrow the filters; undelivered jobs stay new for the next run |
| `AI fields are not available right now` | AI enrichment is temporarily switched off on our side | Your jobs are still delivered, without AI fields; you are not charged for AI |
| `skipped a malformed posting` | One posting on the board had broken data | Nothing; the rest of the board is delivered |

### FAQ

**Why are some fields empty?** Each ATS publishes different fields. For example, Lever and Recruitee only include salary when the employer fills it in, Greenhouse lists seniority only in some boards, and Breezy HR's public feed has no descriptions (so AI fields are limited there). The AI fields fill the gaps from the description text.

**Can you add another ATS?** Open an issue with the ATS name and an example company.

# Actor input Schema

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

One per line. Any of: the company's own careers page (https://www.figma.com/careers, the Actor finds the ATS board behind it); an ATS board URL (https://jobs.lever.co/spotify); 'ats:slug' (greenhouse:airbnb, lever:spotify, ashby:ramp, smartrecruiters:BoschGroup, recruitee:bunq, workable:huggingface, personio:jobleads, teamtailor:career, gem:gem, breezy:acme); or just a company slug to try all ten ATS.

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

Keep jobs whose title contains any of these words. Leave empty for all jobs.

## `excludeKeywords` (type: `array`):

Drop jobs whose title contains any of these words.

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

Keep jobs where any location contains one of these, e.g. 'London', 'Dubai', 'Remote'.

## `workplaceTypes` (type: `array`):

Keep only these workplace types, as reported by the ATS. Add 'unknown' to keep jobs that do not say.

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

Keep jobs published in the last N days. Jobs without a date are kept.

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

Adds the plain-text description, plus free keyword flags for visa sponsorship and relocation.

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

Remembers what this input already delivered, so a scheduled run returns only new postings.

## `aiEnrichment` (type: `boolean`):

Adds AI-extracted visa sponsorship (with the quote), relocation support, remote regions, normalised salary, seniority, years of experience, skills and required languages. Charged per enriched job; failed enrichments are not charged.

## `maxJobs` (type: `integer`):

Stop after this many jobs.

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

Stop after this many jobs from each company, so one large board does not use up the whole run. Jobs held back stay 'new' for the next run.

## Actor input object example

```json
{
  "companies": [
    "https://www.figma.com/careers/",
    "lever:spotify",
    "ashby:ramp"
  ],
  "includeDescription": false,
  "onlyNew": false,
  "aiEnrichment": false,
  "maxJobsPerCompany": 30
}
```

# Actor output Schema

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

All delivered jobs as JSON.

## `jobsOverview` (type: `string`):

Company, title, locations, workplace type, posted date, salary and link.

# 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": [
        "https://www.figma.com/careers/",
        "lever:spotify",
        "ashby:ramp"
    ],
    "maxJobsPerCompany": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("sandy_cornfield/company-jobs-api").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": [
        "https://www.figma.com/careers/",
        "lever:spotify",
        "ashby:ramp",
    ],
    "maxJobsPerCompany": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("sandy_cornfield/company-jobs-api").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": [
    "https://www.figma.com/careers/",
    "lever:spotify",
    "ashby:ramp"
  ],
  "maxJobsPerCompany": 30
}' |
apify call sandy_cornfield/company-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/EsQxTE9dyK5pgdboH/builds/2hqR7BYqhgBqniOG2/openapi.json
