# Ats Jobs API (`jobo.world/ats-jobs-api`) Actor

Search for jobs directly from 75+ ATS platforms (Greenhouse, Lever, Ashby, Workday, iCIMS, Taleo, SuccessFactors, and dozens more). Supports advanced filters for skills, companies, salary, work model, employment type, and experience level. Zero ghost jobs, direct company sources.

- **URL**: https://apify.com/jobo.world/ats-jobs-api.md
- **Developed by:** [Jobo](https://apify.com/jobo.world) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 698 total users, 151 monthly users, 100.0% runs succeeded, 14 bookmarks
- **User rating**: 4.58 out of 5 stars

## Pricing

from $1.30 / 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.
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?

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

**ATS Jobs API** — search **3.9 million+ live jobs** across **150+ ATS platforms** in one call: Greenhouse, Lever, Ashby, Workday, iCIMS, Taleo, SuccessFactors, and more. One normalized JSON schema across every source, verified daily, zero ghost jobs — with live openings from companies like **NVIDIA, Airbnb, IKEA, and OpenAI**. Open the actor, hit **Try for free**, and run the default input (`queries: ["Software Engineer", "Product Manager"]`) — no code or API key required.

[![Service Status](https://img.shields.io/badge/Service%20Status-jobo.world%2Fstatus-brightgreen)](https://jobo.world/status)

### What does ATS Jobs API do?

- Searches **3.9 million+ live jobs** across **150+ ATS platforms** in one call — no board tokens, no per-company setup, no per-vendor integrations
- Filters by **work model, employment type, experience level, salary range, skills, companies, and posting date** — plus `sources` to scope which platforms to search
- Excludes noise with **negative keywords** — prefix any query token with `-` (`["Software Engineer", "-staff"]`)
- Switches between **full-text search and title-only matching** with `search_description` — broad keyword recall or precise title matches
- Returns **de-duplicated, verified listings** — duplicates merged by company + canonical title + listing URL, expired jobs removed daily, so no ghost jobs
- Enriches every job with **AI-extracted data**: typed hard/soft skills, responsibilities, benefits, a 2–3 sentence summary, geocoded locations, USD-normalized salaries, and work-authorization signals (H1B sponsorship, clearance)
- Optionally attaches the **full company profile** — funding, leadership, ratings, tech stack, H1B history — with one switch
- Exports to **JSON, CSV, or Excel**, and plugs into **schedules, webhooks, Zapier, Make, and the Apify API**

### Which ATS platforms are covered?

**150+ platforms.** Two references list every one of them, with the exact ID to
pass in `sources`:

| Reference | Use it for |
|-----------|------------|
| **[jobo.world/docs/sources](https://jobo.world/docs/sources)** | The readable table: every `provider_id` next to its platform name, plus the three accepted aliases |
| **[`GET /api/v1/providers/catalog`](https://enterprise.jobo.world/api/v1/providers/catalog)** | The same list as JSON, no key required — build your integration against this if you need it programmatically |

Both are generated from Jobo's scraper registry, so newly supported platforms
appear there without an actor schema update. Leave `sources` empty to search
every indexed platform, or scope a run with canonical IDs like
`["greenhouse", "lever", "ashby"]`.

> **`sources` is not validated.** A misspelled or unsupported ID is not an
> error — it simply matches nothing, and the run returns `0` results. Copy IDs
> from one of the two references above rather than typing platform names:
> `"Bullhorn"` or `"Workday Recruiting"` will silently return nothing, where
> `"workday"` works.

### Why search jobs across ATS platforms?

Job postings don't live in one place — they're scattered across dozens of applicant tracking systems. Tech startups hire on Greenhouse, Lever, and Ashby; global enterprises run Workday, SuccessFactors, and Taleo; SMBs use BambooHR, JazzHR, or Personio; and a long tail of specialty platforms covers everything from public-sector hiring to hourly work. Scrape any single ATS and you see one slice of the market — and you first have to know which vendor each employer uses.

This actor searches Jobo's entire index instead: **3.9 million+ live jobs** from thousands of company boards across **all 150+ platforms**, in one query, with one schema. That's how you find openings at **NVIDIA and Walmart** (Workday), **Airbnb, Stripe, and Anthropic** (Greenhouse), **IKEA and Deloitte** (SmartRecruiters), **OpenAI and Notion** (Ashby), and **Mistral AI** (Lever) side by side — without caring which ATS each employer happens to run.

#### Can I use the official ATS APIs instead?

Some ATS vendors publish official job APIs — but every one of them is **per-company**. Greenhouse's Job Board API takes one board token per call, Lever's Postings API one company slug, Ashby's one organization name — and Workday has no public jobs API at all. To replicate a cross-platform search you'd need every company's identifier on every ATS, a separate integration per vendor, and your own normalization layer. No ATS offers a public cross-company search API — that's the gap this actor closes: one query across every board Jobo indexes on 150+ platforms, with normalized fields the official feeds don't provide (geocoded locations, USD-normalized salaries, AI-extracted skills).

### What data can you extract?

Every result is a structured job record in Jobo's normalized schema — the same shape across all 150+ platforms and all Jobo actors, so you can mix sources freely. Highlights:

| Field | Description |
|-------|-------------|
| `title` / `normalized_title` | Raw posting title + canonical title for grouping |
| `company` | Company preview: name, website, logo, summary, industries (+ `id` for enrichment) |
| `locations` | Geocoded: city, region, country, latitude/longitude |
| `compensation` | `{min, max, currency, period}`, normalized to annual USD for filtering |
| `employment_type` / `workplace_type` / `experience_level` | e.g. `"Full-time"` / `"Remote"` / `"Mid Level"` |
| `qualifications` | AI-extracted must-have & preferred skills (typed hard/soft), education, certifications |
| `responsibilities` / `benefits` | Bullet lists extracted from the description |
| `summary` / `description` | 2–3 sentence AI recap + full description, HTML stripped |
| `listing_url` / `apply_url` | Canonical listing on the source ATS + direct apply link |
| `is_h1b_sponsor` / `is_work_auth_required` / `is_clearance_required` | Work-authorization signals |
| `date_posted` / `created_at` / `updated_at` | Employer posting date + Jobo index/refresh timestamps |
| `source` | The originating ATS slug — `"greenhouse"`, `"workday"`, `"icims"`, … |

Set `include_company_details: true` to replace the company preview with the **fully enriched profile**: funding rounds and investors, leadership, employee ratings, tech stack, headcount and revenue bands, and H1B filing history. The complete field list is on this page's **Output schema** tab and at [jobo.world/docs](https://jobo.world/docs/api-reference/companies/object).

### How much does it cost?

This actor uses **pay-per-result pricing**: you pay a fixed rate per job record returned — the current rate is in the pricing box on this page. There are no separate compute, proxy, or storage charges, and a run never returns more than `page_size` results, so spend is fully predictable. Apify's **free plan** includes enough credit to pull thousands of jobs, so you can evaluate the full dataset before paying anything.

### How do I search jobs across 150+ ATS platforms?

1. **Open the actor** and click **Try for free** — you'll need a free [Apify account](https://console.apify.com/).
2. **Enter your search** on the Input tab: keep the default `queries` (`["Software Engineer", "Product Manager"]`) or add your own titles and `locations`.
3. **Pick your platforms** (optional): leave `sources` empty to search all 150+ ATSes at once, or scope it to a subset like `["greenhouse", "lever", "ashby"]`.
4. **Narrow with filters** (optional): work model, experience level, salary range, skills, specific companies — or turn `search_description` off for title-only matching.
5. **Click Start**, then **export your results** from the Output tab as JSON, CSV, or Excel — or connect a schedule, webhook, or integration to make it run on autopilot.

### ⬇️ Input

Every field is optional — an empty input returns the newest jobs across all 150+ platforms. Up to **5** `queries` are OR-ed together; prefix a token with `-` to exclude it.

| Parameter | Type | Description |
|-----------|------|-------------|
| `queries` | array (≤5) | Job titles or keywords, OR-ed. `-token` excludes. |
| `search_description` | boolean | `true` (default) = full-text search across title, company, skills, and description; `false` = title-only matching. See below. |
| `sources` | array | ATS platforms to search (e.g. `["greenhouse", "lever"]`). Empty = all 150+. IDs: [jobo.world/docs/sources](https://jobo.world/docs/sources) — unknown IDs match nothing rather than erroring. |
| `locations` | array | Cities, regions, or countries — geocoded server-side. |
| `work_models` | array | `remote`, `hybrid`, `onsite`. |
| `employment_types` | array | `full-time`, `part-time`, `contract`, `internship`, `freelance`, `temporary`. |
| `experience_levels` | array | `intern`, `entry`, `mid`, `senior`, `lead`, `executive`. |
| `skills_include` / `skills_exclude` | array | Match against AI-extracted skills. |
| `companies_include` / `companies_exclude` | array | Company name (whole-name match, case-insensitive), website domain, or Jobo company id. See the FAQ. |
| `min_salary_usd` / `max_salary_usd` | integer | Annual USD bounds; jobs without a disclosed salary are excluded when set. |
| `posted_after` / `posted_before` | string | ISO 8601 (`2026-01-01`) or relative (`7 days ago`). |
| `page` / `page_size` | integer | Page 1–100 × 1–100 results per page (default 50). |
| `include_company_details` | boolean | Attach the full enriched company profile (default `false`). |

The full input schema with defaults is on this page's **Input schema** tab.

#### Title-only matching vs full-text search

`search_description` controls what your `queries` match against:

- **`true` (default) — full-text search.** Queries match the job **title, company, skills, and full description**. Broadest recall, best for keyword discovery — `"python"` finds every role that mentions Python anywhere.
- **`false` — title-only matching.** Queries match the job's **title plus a curated set of same-role alternative titles**: `"Android Developer"` still finds *Android Engineer* roles, but never an *IT Support Engineer* posting that merely lists Android as a skill. Use it when you pass real job titles and want relevance with healthy volume.
- **Double-quoted query — exact title.** Wrap a query in double quotes (`"\"Android Developer\""`) for an exact literal-title phrase match; alternative titles are excluded.

**Remote engineering roles across every platform**

```json
{
  "queries": ["Software Engineer"],
  "work_models": ["remote"],
  "page_size": 100
}
```

**Senior roles, scoped to the three big tech ATSes**

```json
{
  "queries": ["Backend Engineer"],
  "sources": ["greenhouse", "lever", "ashby"],
  "experience_levels": ["senior", "lead"],
  "page_size": 100
}
```

**Exact titles only — no description noise**

```json
{
  "queries": ["Android Developer"],
  "search_description": false,
  "page_size": 100
}
```

### ⬆️ Output example

Results land in the dataset under two views: *Job Listings (all sources)* (one row per job) and *Company details* (populated when `include_company_details` is on). Every row uses the same normalized schema regardless of platform — the `source` field carries the slug of the ATS the job came from (here `"greenhouse"`; on a mixed run you'll also see `"workday"`, `"icims"`, and so on). Export as JSON, CSV, or Excel. A typical record:

```json
{
  "id": "f0f6a7d0-c667-48f7-95bc-a91f172e2d6d",
  "title": "Software Engineer",
  "normalized_title": "Software Engineer",
  "summary": "Design and develop software for capital equipment and medical devices used by cardiac surgeons and electrophysiologists…",
  "company": {
    "id": "6647fb14-d420-434a-a332-9c972016b9b0",
    "name": "AtriCure",
    "website": "https://atricure.com/",
    "logo_url": "https://images.jobo.world/logos/atricure.jpg",
    "industries": ["Medical Devices & Equipment"],
    "details_url": "https://connect.jobo.world/api/companies/6647fb14-d420-434a-a332-9c972016b9b0"
  },
  "locations": [
    {
      "location": "Minneapolis, MN",
      "city": "Minneapolis",
      "region": "Minnesota",
      "country": "United States",
      "latitude": 44.9772995,
      "longitude": -93.2654692
    }
  ],
  "compensation": { "min": 71036, "max": 104186, "currency": "USD", "period": "yearly" },
  "employment_type": "Full-time",
  "workplace_type": "On-site",
  "experience_level": "Mid Level",
  "qualifications": {
    "must_have": {
      "education": ["Bachelor's degree in Systems Engineering, Electrical Engineering, or Computer Engineering"],
      "skills": [
        { "name": "C", "type": "hard" },
        { "name": "C++", "type": "hard" },
        { "name": "Software Development Methodologies", "type": "hard" }
      ]
    },
    "preferred": {
      "skills": [
        { "name": "Rust", "type": "hard" },
        { "name": "Python", "type": "hard" }
      ]
    }
  },
  "is_work_auth_required": true,
  "listing_url": "https://job-boards.greenhouse.io/atricure/jobs/4309998009",
  "apply_url": "https://job-boards.greenhouse.io/atricure/jobs/4309998009#app",
  "source": "greenhouse",
  "date_posted": "2026-07-09T13:47:14Z",
  "description": "…full job description, HTML stripped…"
}
```

### What can you expect from a run?

- **One run returns one page** — up to 100 results per call. Walk `page` 1→100 to reach **10,000 jobs per query**; for full-inventory pulls use [Career Site Jobs Feed](https://apify.com/jobo.world/career-site-jobs-feed) (cursor pagination, 1,000 jobs per batch).
- **Results can mix sources** — a single page is ranked across every platform you include; set `sources` to scope a run to specific ATSes (which usually speeds it up too).
- **Freshness**: every listing is re-verified daily; expired jobs are removed within 24 hours of disappearing from the source board.
- **Salaries** are normalized to annual USD using current FX rates, so `min_salary_usd` works across currencies.
- **Geocoding is best-effort** — loose strings like `"Worldwide"` won't geocode, but the raw location string is always preserved.
- **`industries` can be empty** for long-tail companies that Jobo's enrichment pipeline hasn't profiled yet.
- **`source` carries the originating ATS slug** — handy for routing, analytics, or per-source weighting when you feed the data downstream.

### Integrations, API & MCP

Everything on the Apify platform works out of the box: **schedules** (hourly/daily/weekly runs), **webhooks** on run completion, and one-click integrations with **Zapier, Make, n8n, Slack, Google Sheets, and Google Drive**.

Prefer code? Call this actor as a **multi-ATS jobs API** from Python or JavaScript with the [Apify API clients](https://docs.apify.com/api) — start a run, wait for it, and page through the dataset in a few lines (ready-made snippets are in the **API** section of this page). AI agents can run it through the **[Apify MCP server](https://mcp.apify.com)**, which exposes this actor as a tool.

### Use cases

| Who | What for |
|-----|----------|
| **Job boards** | Cross-ATS aggregators with normalized data from every platform the market uses |
| **AI agents** | Career copilots grounded in the broadest live job dataset — one tool call, 150+ platforms |
| **Recruiters** | Sourcing intel regardless of which ATS an employer happens to run |
| **HR tech** | Market dashboards that don't stop at a single vendor's customer base |
| **Salary research** | Compensation benchmarks across segments — startups to global enterprises |
| **Market research** | Hiring-velocity tracking without per-ATS bias |

### ❓ FAQ

#### My company filter returned zero jobs — why?

One of three causes — the **Company match report** in the run's Output tab gives
a per-name answer:

1. **Not the full stored name.** Matching is whole-name, case-insensitive:
   `Glenmark` won't find `Glenmark Pharmaceuticals`. Passing the company's
   website domain (`glenmark.com`) or Jobo company id works too and sidesteps
   spelling entirely.
2. **Your `sources` filter excludes the company's ATS.** FedEx hires on
   Workday, so `sources: ["greenhouse"]` returns nothing for it however it is
   spelled.
3. **Another filter excluded everything.** `queries` is pre-filled with example
   job titles — clear it to search a company's whole job list.

#### Should I use this actor or a single-ATS actor?

Use **this actor** for cross-platform coverage, or when you don't know (or care) which ATS an employer uses. Use a single-ATS actor like [Greenhouse Jobs Scraper](https://apify.com/jobo.world/greenhouse-jobs-scraper-api) when you only ever need one platform — simpler input, identical output schema.

#### How many ATS platforms are covered?

**150+** — Greenhouse, Lever, Ashby, Workday, iCIMS, Taleo, SuccessFactors, Oracle Cloud, ADP, Paycom, Dayforce, BambooHR, Personio, SmartRecruiters, and many more. The complete, current list is at [jobo.world/docs/sources](https://jobo.world/docs/sources) (readable table) or [`/api/v1/providers/catalog`](https://enterprise.jobo.world/api/v1/providers/catalog) (JSON, no key required).

#### Which ATS platforms have no dedicated actor?

Most of them — this actor covers all 150+. iCIMS, Taleo, SuccessFactors, Dayforce, ADP, Oracle Cloud, Paycom, UKG (`ultipro`, `kronos`), and dozens more have no dedicated Jobo actor and are searchable only here. Set `sources` to canonical IDs from [jobo.world/docs/sources](https://jobo.world/docs/sources).

#### The ATS I need isn't covered — can you add it?

Yes, coverage requests from customers are prioritised — email
<support@jobo.world> with the platform name and, if
you have them, a few live career-site URLs on it (those make a platform far
faster to add). Check the [current list](https://jobo.world/docs/sources) first:
platforms are sometimes indexed under the vendor's own name rather than the one
you know them by.

#### How do I download more than 10,000 jobs?

Use [Career Site Jobs Feed](https://apify.com/jobo.world/career-site-jobs-feed) — it streams the full inventory with cursor pagination at 1,000 jobs per batch, built for ETL pipelines.

#### Are duplicate listings removed?

Yes. Jobo de-duplicates by company + canonical title + listing URL before results are returned, so cross-posted duplicates of the same role are merged.

#### Can I filter by salary?

Yes — `min_salary_usd` / `max_salary_usd`, matched against USD-normalized compensation. Jobs that don't disclose a salary are excluded whenever a salary filter is set.

#### How fresh is the data?

New jobs are indexed within 24 hours of appearing on any of the 150+ platforms; every listing is re-verified daily and removed within 24 hours of expiring.

#### Where can I check if the API behind this actor is up?

At [jobo.world/status](https://jobo.world/status) — the live status page for the Jobo Connect API that powers every Jobo actor.

### ⚖️ Is it legal to scrape ATS job listings?

Yes — this actor only extracts publicly posted job listings, the content employers publish specifically to be found and shared. It does not collect private user data. Note that scraped results can incidentally contain personal data (e.g., a recruiter's name in a job description); personal data is protected by the GDPR and similar regulations, so only process it with a legitimate reason and consult a lawyer if unsure. Read more in Apify's guide to [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

All ATS names are trademarks of their respective owners. This actor is an independent product and is not affiliated with, endorsed by, or sponsored by any of them.

### 🔗 Related actors

| Actor | Best for |
|-------|----------|
| [Career Site Jobs Feed](https://apify.com/jobo.world/career-site-jobs-feed) | Bulk export for data pipelines — cursor pagination, 1,000 jobs/batch |
| [AI Deep Job Search](https://apify.com/jobo.world/ai-deep-job-search) | Describe your ideal job in plain English, get AI-scored matches |
| [Greenhouse Jobs Scraper](https://apify.com/jobo.world/greenhouse-jobs-scraper-api) | 175,000+ jobs from tech companies on Greenhouse |
| [Workday Jobs Scraper](https://apify.com/jobo.world/workday-jobs-scraper-api) | 850,000+ jobs from Fortune 500 employers on Workday |
| [Lever Jobs Scraper](https://apify.com/jobo.world/lever-jobs-scraper-api) | 75,000+ jobs from VC-backed startups on Lever |

### About Jobo & support

Jobo builds job-data infrastructure: a normalized, daily-verified index of jobs scraped directly from company ATS boards, powering job boards, AI agents, and HR-tech products.

- **Questions or bugs?** Open a ticket on this actor's **Issues** tab — issues are answered within hours.
- **Website**: [jobo.world](https://jobo.world) · **Enterprise API**: [jobo.world/enterprise](https://jobo.world/enterprise) · **API status**: [jobo.world/status](https://jobo.world/status)
- **Email**: enrico@jobo.world

# Actor input Schema

## `queries` (type: `array`):

Job titles or keywords to search for. Multiple queries are OR'd together. Up to 5 keywords. Adding more rarely improves results — narrow your filters (skills, companies, locations) for better matches.

## `search_description` (type: `boolean`):

When ON (default), your queries match against the job title, company, skills, AND the job description — broad recall, best for keyword discovery (e.g. 'python' finds roles that list Python as a skill). Turn OFF for title-only matching: queries match the job's title plus a curated set of same-role alternative titles, so 'Android Developer' also finds 'Android Engineer' roles — but never jobs that merely mention the terms in their description or skills (e.g. an 'IT Support Engineer' that lists Android as a skill). Use OFF when you pass exact job titles and want relevance with healthy volume. Wrap a query in double quotes for an exact literal-title phrase match (alternative titles excluded).

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

Cities, regions, or countries to filter by. The API performs server-side geocoding for accurate location matching.

## `sources` (type: `array`):

Filter by canonical ATS provider IDs (e.g. greenhouse, lever, ashby). Leave empty to search every indexed platform. The full list of 150+ IDs is at https://jobo.world/docs/sources (readable table) or https://enterprise.jobo.world/api/v1/providers/catalog (JSON, no key required). NOT validated: an unknown or misspelled ID is not an error, it simply matches nothing and the run returns 0 results. Copy the IDs from those references rather than typing platform names.

## `work_models` (type: `array`):

Filter by where the work is performed. Accepts: 'remote', 'hybrid', 'onsite'. Leave empty for all.

## `employment_types` (type: `array`):

Filter by employment type. Accepts: 'full-time', 'part-time', 'contract', 'internship', 'freelance', 'temporary'. Leave empty for all.

## `experience_levels` (type: `array`):

Filter by seniority. Accepts: 'intern', 'entry', 'mid', 'senior', 'lead', 'executive'. Leave empty for all.

## `skills_include` (type: `array`):

Only return jobs that require ANY of these skills (e.g., 'Python', 'React', 'AWS'). Matched case-insensitively against the job's extracted qualifications.

## `skills_exclude` (type: `array`):

Exclude jobs that require ANY of these skills. Useful for filtering out unwanted tech stacks.

## `companies_include` (type: `array`):

Only return jobs from these companies. Each entry can be the company's FULL name as stored in the Jobo index, its website domain (e.g. fedex.com), or its Jobo company id — name matching is on the whole name, case-insensitive, and is NOT a partial or "contains" match. "Glenmark" will not find "Glenmark Pharmaceuticals". Common legal suffixes are handled, so "FedEx Corporation" does find "FedEx". If a run returns nothing, open Output → Company match report to see which names matched and which did not. Tip: the exact stored name is the company.name field on any job result. To build a list, run a search without this filter and copy the company.name values from the output instead of typing names by hand.

## `companies_exclude` (type: `array`):

Exclude jobs from these companies. Useful for filtering out staffing agencies or companies you have already applied to. Entries take the same forms as the include filter: a whole company name, a website domain, or a Jobo company id. An entry that matches no stored company is a silent no-op: it excludes nothing and the run does not fail.

## `min_salary_usd` (type: `integer`):

Minimum annual salary in USD. Jobs without salary data are excluded when this filter is set.

## `max_salary_usd` (type: `integer`):

Maximum annual salary in USD. Can be combined with min\_salary\_usd for a range.

## `posted_after` (type: `string`):

Only show jobs whose employer posting date is after this date. Accepts ISO 8601 dates (e.g., '2025-01-01T00:00:00Z') or relative strings (e.g., '7 days ago', '1 month').

## `posted_before` (type: `string`):

Only show jobs whose employer posting date is before this date. Accepts ISO 8601 dates or relative strings.

## `page` (type: `integer`):

Page number for paginated results. Up to page 100.

## `page_size` (type: `integer`):

Number of results per page (1-100).

## `include_company_details` (type: `boolean`):

When enabled, replaces the lightweight company preview on each job with the fully enriched company profile (funding, leadership, ratings, tech stack, H1B stats, etc.) fetched from GET /api/companies/{id}. Companies are deduplicated, so each unique company is fetched only once per run. Slower and uses more API calls — leave off if you only need basic company info.

## Actor input object example

```json
{
  "queries": [
    "Software Engineer",
    "Product Manager"
  ],
  "search_description": true,
  "page": 1,
  "page_size": 50,
  "include_company_details": false
}
```

# Actor output Schema

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

No description

## `csv_export` (type: `string`):

No description

## `company_match_report` (type: `string`):

Which of your companies\_include entries matched a company, which did not, and which are indexed on a different ATS. Written whenever a company filter is used.

# 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 = {
    "queries": [
        "Software Engineer",
        "Product Manager"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobo.world/ats-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 = { "queries": [
        "Software Engineer",
        "Product Manager",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jobo.world/ats-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 '{
  "queries": [
    "Software Engineer",
    "Product Manager"
  ]
}' |
apify call jobo.world/ats-jobs-api --silent --output-dataset

```

## MCP server setup

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