# ATS Jobs Search API: Greenhouse, Lever & Ashby Career Site Jobs (`datagleaner/career-jobs-scraper`) Actor

Greenhouse jobs API, Lever jobs API and Ashby jobs search in one: ATS job search over 10,330 bundled career site boards (about 315k open jobs, checked 2026-10-21), plus Workday and 4 more. New jobs in the last hour, 24 h or week. $0.002 per job.

- **URL**: https://apify.com/datagleaner/career-jobs-scraper.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Jobs
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$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

## ATS Jobs Search API: Greenhouse, Lever & Ashby Career Site Jobs

**A Greenhouse jobs API, Lever jobs API and Ashby jobs API in one: ATS job search across career site jobs and job postings, read live on every run.** Search 10,330 bundled career boards by job title, or paste any career-page URL. Filter to new jobs in the last hour, 24 hours or week with `timeRange`, and to one ATS with `ats`. Each job comes in one format: title, department, location, remote flag, salary range when published, posted date and apply link. Also reads Workday, SmartRecruiters, Workable, Recruitee and Personio pages. No login, no browser, no proxy.

**Coverage, measured:** 10,330 bundled boards (5,494 Greenhouse, 1,566 Lever, 3,270 Ashby). The 8,177 boards bundled on 2026-10-08 were still about 97% live in a 400-board sample on 2026-10-20; 2,153 more were added on 2026-10-21, each one answering with at least one open job that day. A full scan on 2026-10-21 reached 10,288 of the 10,330 boards (42 no longer exist). That is roughly 315,000 open jobs (estimate, plus or minus 25%).

**Price: $0.002 per job** ($2 per 1,000), no start fee. See Pricing below.

### Why use this one

- **One format for 8 ATSes.** The same fields whether the job is on Greenhouse or Workday, with `ats` telling you which.
- **Salary as numbers** (`salaryMin`, `salaryMax`, currency, period) where the company publishes pay: Ashby, Lever, Recruitee and Greenhouse.
- **Live, not a stale index.** Any company you name is fetched when you run, and a guessed company board is dropped if its name does not match, so you do not get another company's jobs.
- **Only new jobs on a schedule.** `onlyNewSinceLastRun` returns and bills only jobs not seen in earlier runs.
- **Press Start and see results.** The form is prefilled with a search of all bundled boards for engineer jobs posted in the last 7 days (100 jobs, about $0.20).
- **New jobs in the last hour, 24 hours or week.** Set `timeRange` to `1h`, `24h` or `7d`.
- **Honest limit:** only public, open jobs; plain-name lookup tries Greenhouse, Lever and Ashby only (paste the URL for the others); Workday, SmartRecruiters, Workable and Personio do not publish structured pay.

### Minimal input

```json
{"companies": ["https://boards.greenhouse.io/stripe", "https://jobs.ashbyhq.com/openai"], "titleKeywords": ["engineer"], "maxItems": 50}
```

### Sample output row (real platform run, description left out)

```json
{
  "company": "OpenAI",
  "ats": "ashby",
  "title": "Research Engineer",
  "department": "Research",
  "locations": [
    "San Francisco"
  ],
  "city": "San Francisco",
  "country": "US",
  "employmentType": "full_time",
  "salary": {
    "min": 250000,
    "max": 445000,
    "currency": "USD",
    "period": "year"
  },
  "salaryText": "USD 250,000-445,000 / year",
  "postedAt": "2025-04-05T00:03:20+00:00",
  "applyUrl": "https://jobs.ashbyhq.com/openai/240d459b-696d-43eb-8497-fab3e56ecd9b/application",
  "jobUrl": "https://jobs.ashbyhq.com/openai/240d459b-696d-43eb-8497-fab3e56ecd9b",
  "boardUrl": "https://jobs.ashbyhq.com/openai",
  "source": "https://jobs.ashbyhq.com/openai",
  "scrapedAt": "2026-10-11T07:11:28+00:00"
}
```

### What you get

One item per job, with the same fields whatever the ATS:

| Field | Meaning |
| --- | --- |
| `company`, `companySlug` | The company's display name and its board name on the ATS |
| `ats` | `greenhouse`, `lever`, `ashby`, `workday`, `smartrecruiters`, `workable`, `recruitee` or `personio` |
| `jobId` | The ATS's own job ID. Jobs are de-duplicated on `ats` + `jobId` |
| `boardUrl` | The company's career page on the ATS |
| `title`, `department`, `team` | As the company lists them (`team` is only filled by ATSes that have one) |
| `locations` | List of location strings |
| `workArrangement` | `remote`, `hybrid` or `onsite`, from the ATS's workplace type or the location text; `null` when not stated |
| `remote` | `true` for fully remote, `false` for hybrid or on-site, `null` when unknown |
| `employmentType` | `full_time`, `part_time`, `contract`, `internship`, `temporary` or `other` |
| `seniority` | `intern`, `junior`, `senior`, `lead`, `manager`, `principal`, `director` or `executive`, read from the title; `null` when the title says nothing |
| `salary` | `{min, max, currency, period}` when the job lists pay, otherwise `null` |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText` | The same pay as flat columns (`salaryText` is a readable string); all `null` when no pay is listed |
| `postedAt`, `updatedAt` | ISO 8601 UTC. `updatedAt` is `null` where the ATS has no such date |
| `applyUrl`, `jobUrl` | Link to apply, and link to the job page |
| `descriptionText`, `descriptionHtml` | Full description (when "Include job descriptions" is on) |
| `source`, `scrapedAt` | The entry you gave (or `bundled-list`), and when the item was fetched |

Not every ATS publishes every field. Salary comes through on Ashby, Lever (when the company fills it in), Recruitee, and Greenhouse (from the pay range the company publishes on the job; this needs "Include job descriptions" on, because Greenhouse pay comes with the job detail). The other ATSes do not expose pay in structured form, so `salary` is `null` for them.

### Input examples

Jobs at a few companies (paste any career-page URLs):

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/openai",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://jobs.smartrecruiters.com/ServiceNow",
    "https://apply.workable.com/huggingface",
    "https://bunq.recruitee.com"
  ],
  "titleKeywords": ["data engineer", "analytics"],
  "locations": ["London", "Remote"],
  "postedWithinDays": 30,
  "maxJobsPerCompany": 50
}
```

A company name or website instead of a URL (the Actor probes Greenhouse, Lever and Ashby):

```json
{ "companies": ["Anthropic", "datadog.com", "greenhouse:airbnb"] }
```

Search the bundled list for a job title:

```json
{
  "searchAllCompanies": true,
  "titleKeywords": ["machine learning engineer"],
  "timeRange": "24h",
  "ats": ["lever", "greenhouse"],
  "remoteOnly": true,
  "maxJobsPerCompany": 5,
  "maxItems": 500
}
```

#### Input fields

- `companies`: career-page URLs, `ats:slug` shortcuts (for example `lever:spotify`), company names or websites.
- `titleKeywords`: keep a job if its title contains any of these words.
- `excludeTitleKeywords`: drop jobs whose title contains any of these words (for example `intern`, `sales`). Applied after `titleKeywords`.
- `departments`: keep a job if its department or team contains any of these texts. Jobs from companies that publish no department are left out when this is set.
- `locations`: keep a job if any of its locations contains any of these texts.
- `remoteOnly`: keep only jobs the ATS marks as remote.
- `postedWithinDays`: keep jobs posted or updated in the last N days. Jobs with no date are kept.
- `timeRange`: `1h`, `24h`, `7d` or `30d`. Keeps jobs posted or updated in that window, with hour precision where the ATS publishes a timestamp (Greenhouse, Lever and Ashby do). Jobs with no date are kept. The later cut-off wins if `postedWithinDays` or `postedAfter` is also set.
- `ats`: only return jobs from these ATSes (`greenhouse`, `lever`, `ashby`, `workday`, `smartrecruiters`, `workable`, `recruitee`, `personio`). Empty means all.
- `postedAfter`: keep jobs posted or updated on or after this date (`YYYY-MM-DD`). Jobs with no date are kept. If `postedWithinDays` is also set, the later cut-off wins.
- `maxJobsPerCompany` (default 20), `maxItems` (default 200; the form prefills 100): limits per company and for the whole run.
- `includeDescription` (default on): turn off for a faster run.
- `searchAllCompanies`: search the bundled boards. `concurrency` (default 10, max 20) sets how many companies are fetched in parallel.
- `requestDelaySeconds` (default 0.2), `proxyConfiguration`: pacing between page requests, and an optional proxy.
- `onlyNewSinceLastRun` (default off), `stateKey` (default `default`): monitor mode, see below.

Personio boards work the same way: paste `https://<company>.jobs.personio.de`. A run with no companies and the search switched off returns a 5-job example from OpenAI's Ashby board.

### Scheduled monitoring

Set `onlyNewSinceLastRun` to `true` on a scheduled run and the Actor returns, and charges for, only jobs that earlier runs with the same `stateKey` have not already returned. Use a different `stateKey` for each schedule or search so they do not share memory. The list of seen jobs is kept in the named key-value store `career-jobs-state` on your account. It is ignored in the built-in example run.

```json
{ "companies": ["lever:spotify"], "titleKeywords": ["engineer"], "onlyNewSinceLastRun": true, "stateKey": "spotify-engineering" }
```

### Output example

```json
{
  "company": "OpenAI",
  "companySlug": "openai",
  "ats": "ashby",
  "jobId": "8fb1615c-34bf-47c4-a1d1-b7b2f836bbd3",
  "title": "Technical Program Manager, Compute Infrastructure",
  "department": "Technical Program Management",
  "team": "Technical Program Management",
  "locations": ["San Francisco"],
  "workArrangement": null,
  "remote": null,
  "employmentType": "full_time",
  "seniority": null,
  "salary": { "min": 257000, "max": 335000, "currency": "USD", "period": "year" },
  "salaryMin": 257000,
  "salaryMax": 335000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salaryText": "USD 257,000-335,000 / year",
  "postedAt": "2026-03-12T16:38:15+00:00",
  "updatedAt": null,
  "applyUrl": "https://jobs.ashbyhq.com/openai/8fb1615c-34bf-47c4-a1d1-b7b2f836bbd3/application",
  "jobUrl": "https://jobs.ashbyhq.com/openai/8fb1615c-34bf-47c4-a1d1-b7b2f836bbd3",
  "boardUrl": "https://jobs.ashbyhq.com/openai",
  "descriptionText": "ABOUT THE TEAM ...",
  "descriptionHtml": "<h3><strong>About the Team</strong></h3> ...",
  "source": "https://jobs.ashbyhq.com/openai",
  "scrapedAt": "2026-10-08T15:32:10+00:00"
}
```

### Pricing

Price: **$0.002 per job** ($2 per 1,000 jobs, pay per event, event name `job`), in force from 21 October 2026. You pay only for jobs that are returned. Set a maximum total charge on the run and the Actor stops when it is reached.

Worked example: you track 40 companies and each run returns about 250 matching jobs. One run costs 250 x $0.002 = **$0.50**. Running it daily for a month costs about $15.

### Use with Python

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datagleaner/career-jobs-scraper").call(run_input={
    "companies": ["https://boards.greenhouse.io/stripe", "https://jobs.ashbyhq.com/openai"],
    "titleKeywords": ["engineer"],
    "maxItems": 10,
    "includeDescription": False,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["company"], "|", job["title"], "|", job["locations"], "|", job["jobUrl"])
```

This run returns at most 10 jobs.

### Use with JavaScript / Node.js

```js
// npm install apify-client
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/career-jobs-scraper').call({
    companies: ['https://jobs.lever.co/spotify', 'https://jobs.ashbyhq.com/openai'],
    titleKeywords: ['data'],
    maxItems: 10,
    includeDescription: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const job of items) console.log(job.company, '|', job.title, '|', job.locations, '|', job.jobUrl);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/career-jobs-scraper`

Minimal input:

```
{"companies": ["https://boards.greenhouse.io/stripe"], "maxItems": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/career-jobs-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/career-jobs-scraper`. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/career-jobs-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Find remote machine learning engineer jobs posted in the last 14 days at Stripe, OpenAI and Spotify, and give me a table with company, title, location, salary and apply link." The agent calls the Actor with `companies`, `titleKeywords`, `remoteOnly` and `postedWithinDays`, then reads the jobs from the run's dataset. Without the `tools` parameter the server can still find this Actor with its `search-actors` tool.
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/career-jobs-scraper")
result = tool.invoke({"run_input": json.loads('{"companies": ["https://boards.greenhouse.io/stripe"], "maxItems": 10}')})
```

### Use cases

- Job boards and aggregators that need fresh listings from many employers.
- Recruiters and sales teams watching which companies are hiring for a role (a hiring signal for sales outreach).
- Salary research from jobs that publish pay ranges.
- Labour-market analysis: job counts by company, department, location or ATS.

### Limits

- Only open, public jobs are returned. Closed jobs and anything behind a login are not visible.
- Plain-name lookup only tries Greenhouse, Lever and Ashby. For the other ATSes, paste the career-page URL.
- The bundled list covers Greenhouse, Lever and Ashby boards. It was built on 2026-10-08 and extended on 2026-10-21, and boards that have since closed are skipped without error. Boards added after that date are not in it; add them in `companies`.
- Lever boards hosted in the EU region are found when you paste their URL; the bundled list holds global boards.
- Workday returns at most 2,000 jobs per company, and its descriptions need one extra request per job.

### FAQ

**How do I scrape Greenhouse, Lever, Ashby or Workday jobs?** Paste the company's board URL into `companies` (for example `https://boards.greenhouse.io/stripe` or `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`). The Actor detects the ATS and returns every open job in the same format.

**Can I search jobs across many companies at once?** Yes. Switch on `searchAllCompanies`, set `titleKeywords`, and the Actor searches 10,330 bundled Greenhouse, Lever and Ashby boards, stopping at `maxItems`.

**Does it return salary?** When the company publishes pay: on Ashby, Lever, Recruitee and Greenhouse. Workday, SmartRecruiters, Workable and Personio do not expose pay in structured form, so `salary` is `null` there.

**Does it need a proxy?** No. The endpoints are public and work from Apify's datacenter IPs. A proxy field is there if you want one.

**How do I find the right URL for a company?** Open the company's careers page and click a job. If the address contains `greenhouse.io`, `lever.co`, `ashbyhq.com`, `myworkdayjobs.com`, `smartrecruiters.com`, `workable.com`, `recruitee.com` or `personio.de`, paste the board part of it (for example `https://jobs.lever.co/spotify`).

**Why is `remote` sometimes null?** Some ATSes do not say whether a job is remote. `null` means unknown, not on-site. With `remoteOnly` on, unknown jobs are left out.

**Why is a company missing from a search?** It may not be on Greenhouse, Lever or Ashby, or not in the bundled list. Add its URL to `companies`.

**How fresh is the data?** It is fetched live on every run.

**How long does a search across all companies take?** Scanning every bundled board (about 15,700 requests, since Greenhouse boards need a second call for departments) took about 6 minutes at the default concurrency in our 2026-10-21 test, with a rare keyword that matched almost nothing. A run stops as soon as `maxItems` is reached, so a common title returns much sooner.

### Responsible use

This Actor reads public job postings that companies publish for anyone to see. Job postings can name a recruiter or hiring manager; if you store or contact people from this data, you are responsible for following the data-protection and anti-spam rules that apply to you. Respect each company's terms, and keep the request rate modest.

# Actor input Schema

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

Career-page URLs such as https://boards.greenhouse.io/stripe, https://jobs.lever.co/netflix, https://jobs.ashbyhq.com/openai, https://<tenant>.wd5.myworkdayjobs.com/<site>, https://jobs.smartrecruiters.com/<company>, https://apply.workable.com/<company>, https://<company>.recruitee.com or https://<company>.jobs.personio.de. You can also write 'greenhouse:stripe', or a plain company name or website: the Actor then tries the Greenhouse, Lever and Ashby slugs for it.

## `titleKeywords` (type: `array`):

Keep only jobs whose title contains at least one of these words (case-insensitive), for example data engineer, product manager. Leave empty for all jobs.

## `excludeTitleKeywords` (type: `array`):

Drop jobs whose title contains any of these words (case-insensitive), for example intern, sales. Applied after the title keywords.

## `departments` (type: `array`):

Keep only jobs whose department or team contains at least one of these texts, for example Engineering, Marketing. Jobs from a company that publishes no department are left out when this is set.

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

Keep only jobs with a location containing at least one of these texts, for example London, Germany, Remote. Leave empty for all locations.

## `countries` (type: `array`):

Keep only jobs located in these countries, as two-letter codes or names, for example US, GB, Germany. Matches any location of the job. Jobs whose country cannot be worked out are left out. Leave empty for all countries.

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

Keep only jobs the company marks as remote. Jobs where the ATS does not say are left out when this is on.

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

Keep only jobs posted or updated in the last N days. Jobs with no date are kept.

## `timeRange` (type: `string`):

Quick freshness filter: only jobs posted or updated in the last hour (1h), 24 hours (24h), 7 days (7d) or 30 days (30d). Hour precision where the ATS publishes a timestamp; jobs with no date are kept. If Posted within the last N days or Posted after is also set, the later cut-off wins.

## `ats` (type: `array`):

Only return jobs from these applicant tracking systems. Applies to the bundled-board search and to the Companies you list. Leave empty for every ATS.

## `postedAfter` (type: `string`):

Keep only jobs posted or updated on or after this date, YYYY-MM-DD. Jobs with no date are kept. If Posted within the last N days is also set, the later cut-off wins.

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

Upper bound on jobs returned for each company, after the filters.

## `maxItems` (type: `integer`):

Upper bound on jobs across all companies. The run stops once it is reached.

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

Return descriptionText and descriptionHtml. Turn off for a faster run; SmartRecruiters, Workable and Workday need one extra request per job for the description.

## `searchAllCompanies` (type: `boolean`):

Search the Actor's bundled list of about 8,000 company boards on Greenhouse, Lever and Ashby instead of the example companies above (leave Companies as it is, or add your own to search them as well). Use it with Job title keywords and Max jobs in total.

## `concurrency` (type: `integer`):

How many companies are fetched at the same time. Each one is a separate site, so 10 is polite; the maximum is 20.

## `requestDelaySeconds` (type: `number`):

Base pause between page requests to the same company; the actual pause is randomised up to 1.5x.

## `onlyNewSinceLastRun` (type: `boolean`):

For scheduled runs: return only jobs that earlier runs with the same state key have not already returned, and pay only for those. The seen list is kept in the named key-value store 'career-jobs-state' on your account. Ignored in the built-in example run.

## `stateKey` (type: `string`):

Name of the seen-jobs list for monitor mode. Use a different key for each schedule or search so they do not share memory.

## `proxyConfiguration` (type: `object`):

Optional. These endpoints work without a proxy from Apify datacenter IPs.

## Actor input object example

```json
{
  "titleKeywords": [
    "engineer"
  ],
  "remoteOnly": false,
  "postedWithinDays": 7,
  "maxJobsPerCompany": 20,
  "maxItems": 100,
  "includeDescription": true,
  "searchAllCompanies": true,
  "concurrency": 10,
  "requestDelaySeconds": 0.2,
  "onlyNewSinceLastRun": false,
  "stateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "titleKeywords": [
        "engineer"
    ],
    "postedWithinDays": 7,
    "maxItems": 100,
    "includeDescription": false,
    "searchAllCompanies": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/career-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 = {
    "titleKeywords": ["engineer"],
    "postedWithinDays": 7,
    "maxItems": 100,
    "includeDescription": False,
    "searchAllCompanies": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/career-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 '{
  "titleKeywords": [
    "engineer"
  ],
  "postedWithinDays": 7,
  "maxItems": 100,
  "includeDescription": false,
  "searchAllCompanies": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call datagleaner/career-jobs-scraper --silent --output-dataset

```

## MCP server setup

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