# Job Listings API - 9 ATS platforms, live from career pages (`alexdany/company-jobs-api`) Actor

Live jobs straight from companies' own career pages across 9 ATS platforms: Workday, Greenhouse, Ashby, Lever, Workable, SmartRecruiters, BambooHR, Breezy, Personio. No blocking, no proxies. 292 companies pre-resolved, including NVIDIA, Salesforce, Intel, Micron, T-Mobile and Boeing.

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

## Pricing

from $1.20 / 1,000 results

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

## Company Career Site Jobs API

Pull **live job listings straight from companies' own career pages**: Workday, Greenhouse, Ashby, Lever, Workable, SmartRecruiters, BambooHR, Breezy and Personio.

**298 companies come pre-resolved and bundled**, so a lookup for them is instant and costs you nothing extra. NVIDIA, Salesforce, Intel, Micron, T-Mobile, Boeing, Mastercard, Stripe, Notion and 289 more.

Give it a company domain. It figures out which ATS that company uses, finds the job board, and returns clean, normalized jobs.

```
stripe.com   →  greenhouse:stripe                      →  746 jobs
micron.com   →  workday:micron.wd1/External            → 2903 jobs
notion.so    →  ashby:notion                           →  148 jobs
```

### Why this instead of scraping a job board

Job-board scrapers fight anti-bot systems every single day. They need residential proxies, they get blocked, and runs fail.

This Actor reads the **public JSON endpoints that companies publish on purpose**, because companies *want* their openings found. So:

- **No proxies.** Nothing to pay for, nothing to configure.
- **No blocking.** The source is not defending itself against you.
- **Fresh at the source.** Not a re-scrape of an aggregator that re-scraped someone else.
- **Nine platforms, one shape.** Every ATS is normalized into the same record, so you never write per-source parsing code.
- **Workday included.** Most large employers run Workday, and its boards are not linked from their careers pages, so they are the hardest to reach. The bundled list already carries 15 of them.
- **It retries.** Transient `429` and `502` responses are retried with backoff and `Retry-After` is respected, so a hiccup does not silently cost you listings.

### What you get per job

`title` · `url` · `location` · `department` · `employmentType` · `remote` · `postedAt` · `compensation` (where published) · `description` (plain text, optional) · `ats` · `companySlug` · `jobId`

Every ATS is normalized into the same shape, so you never write per-source parsing code.

### Input

```json
{
  "companies": ["stripe.com", "micron.com", "greenhouse:figma", "workday:nvidia.wd5/NVIDIAExternalCareerSite"],
  "keywords": ["engineer", "designer"],
  "location": "London",
  "remoteOnly": false,
  "postedWithinDays": 14,
  "includeDescription": false,
  "maxJobs": 1000,
  "useSeedList": false
}
```

| Field | What it does |
|---|---|
| `companies` | Company domains, or direct board refs like `greenhouse:stripe`. Domains are resolved automatically. |
| `keywords` | Keep only jobs whose title contains one of these words. |
| `location` | Keep only jobs whose location contains this text. |
| `remoteOnly` | Keep only remote roles. |
| `postedWithinDays` | Keep only recently posted or updated roles. `0` means no limit. |
| `includeDescription` | Turn off for smaller, cheaper output. On Workday this also skips the per-job detail call, so runs are much faster. |
| `maxJobs` | Hard cap, so a run can never surprise you with cost. |
| `useSeedList` | Run across all 298 bundled companies without listing them yourself. Still respects `maxJobs`. |

### Output

```json
{
  "ats": "workday",
  "companySlug": "micron.wd1/External",
  "jobId": "JR82318",
  "title": "Senior CAD Engineer - Layout/Verification",
  "url": "https://micron.wd1.myworkdayjobs.com/en-US/External/job/Boise-ID-Main-Site/Senior-CAD-Engineer_JR82318",
  "location": "Boise ID Main Site (+1 more)",
  "postedAt": "2026-10-31",
  "employmentType": "Full time",
  "companyInput": "micron.com",
  "scrapedAt": "2026-10-31T17:58:12.004Z"
}
```

The run also stores a `RESOLUTION_REPORT` in the key-value store showing which companies resolved, to which ATS, and how many jobs each returned.

### Who uses this

- **Job boards and aggregators** that want first-party listings instead of recycled ones.
- **Recruiting and talent teams** tracking who is hiring, for what, and where.
- **Investors and market researchers** reading hiring as a growth signal.
- **Sales teams** using open roles as a buying signal.
- **Anyone building with AI agents** that need a reliable jobs feed.

### Pricing

Per 1,000 jobs returned, by your Apify plan:

| Your plan | Free | Starter | Scale | Business |
|---|---|---|---|---|
| Job returned | $3.00 | $2.80 | $2.00 | **$1.20** |

Resolving a company that is not in the bundled list costs $0.01 once. The 298 bundled companies resolve for free: you are only charged when the Actor has to go and find a board it has not seen before.

Platform usage is included. You only pay for what comes back.

### Coverage

Supported today: **Workday** · **Greenhouse** · **Ashby** · **Lever** · **Workable** · **SmartRecruiters** · **BambooHR** · **Breezy** · **Personio**.

Bundled and pre-resolved: **298 companies** (137 Greenhouse, 99 Ashby, 26 Lever, 21 Workday, 11 SmartRecruiters, 3 Workable, 1 Breezy).

Workday boards need a tenant, a pod and a site name, written as `tenant.wdN/SiteName`, for example `micron.wd1/External`. The bundled list already holds these for the companies above; for anything else, pass the ref directly.

If a company you need does not resolve, open an issue on the Actor and it gets added.

### Notes

- Only public job board endpoints are read. No logins, no private data, no personal data about applicants.
- If a domain cannot be resolved, the run continues and reports it instead of failing.

***

Need only *which* ATS a company uses, not the listings? See **[ATS Detector](https://apify.com/alexdany/ats-detector)**.

# Actor input Schema

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

Company domains (stripe.com) or direct board references (greenhouse:stripe, ashby:ramp, lever:spotify). Domains are resolved to the right ATS automatically.

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

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

## `location` (type: `string`):

Keep only jobs whose location contains this text.

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

Keep only jobs flagged or described as remote.

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

Keep only jobs posted or updated within this many days. 0 means no limit.

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

Include the plain-text job description. Turn off for smaller, cheaper output.

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

Hard cap on jobs returned, so a run can never surprise you with cost.

## `useSeedList` (type: `boolean`):

Run across the 185 companies already resolved and bundled with this Actor. Respects Max jobs, so it cannot run away with cost.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "ramp.com",
    "vercel.com"
  ],
  "keywords": [],
  "location": "",
  "remoteOnly": false,
  "postedWithinDays": 0,
  "includeDescription": true,
  "maxJobs": 1000,
  "useSeedList": false
}
```

# Actor output Schema

## `jobs` (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 = {
    "companies": [
        "stripe.com",
        "ramp.com",
        "vercel.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexdany/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": [
        "stripe.com",
        "ramp.com",
        "vercel.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("alexdany/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": [
    "stripe.com",
    "ramp.com",
    "vercel.com"
  ]
}' |
apify call alexdany/company-jobs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexdany/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/TN0waIriP1ZB1Mxh1/builds/FperOevMmecQldDsO/openapi.json