# Job Listings Scraper: 180+ Job Boards & ATS Platforms (`code-node-tools/job-listings-scraper`) Actor

Scrape job listings from 180+ boards & ATS platforms (Greenhouse, Lever, Workday, SmartRecruiters, iCIMS, Ashby, BambooHR, RemoteOK, hh.ru, Gupy...) via one public API. No login or API key. Full descriptions + optional company enrichment.

- **URL**: https://apify.com/code-node-tools/job-listings-scraper.md
- **Developed by:** [CodeNodeTools](https://apify.com/code-node-tools) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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/platform/actors/running/actors-in-store#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

## Job Listings Scraper — Job Listings from 180+ Job Boards & ATS Platforms (No API Key)

Scrape structured, ready-to-use job listings aggregated from **Greenhouse, Lever, Workday, SmartRecruiters, iCIMS, Ashby, BambooHR, Personio, Teamtailor, Recruitee, LinkedIn-style job aggregators, and 180+ other job boards and applicant tracking systems (ATS)** — all through a single request, with **zero login, cookies, or API key required**.

This Actor is a thin, fast wrapper around a public job search API that already aggregates and normalizes postings across hundreds of company career pages and ATS platforms, so you get clean, structured JSON on every run instead of brittle CSS selectors or anti-bot fights.

Use it for **job board aggregation, recruiting pipelines, lead generation from hiring signals, sales intelligence, labor market research, salary benchmarking, competitor hiring analysis, and remote-job datasets.**

***

### Why use this Actor

- **No authentication, no API key, no login walls** — just an HTTP request.
- **Full job description included per item** (HTML, plain text, or Markdown) — no follow-up request per job needed.
- **180+ sources in one query** — spans major ATS platforms (Greenhouse, Lever, Workday, iCIMS, SmartRecruiters, Ashby, BambooHR...), regional job boards (hh.ru, Djinni, Gupy, Bayt, InfoJobs, NoFluffJobs, Arbeitnow...), and remote-work aggregators (RemoteOK, Remotive, WeWorkRemotely, Working Nomads, Himalayas...).
- **Rich faceted filtering** — region, country, city, remote/hybrid/onsite, seniority, category, skills, industry domain, company type/size, salary range, years of experience, posting language, visa sponsorship, and how recently a job was posted.
- **Optional company enrichment** — attach firmographic data (headcount, HQ country, industries, YC batch/status, founding year, company type) for each job's employer, deduplicated so a company with 200 open roles only triggers **one** lookup for the whole run.
- **Built for pipelines** — clean, flat, dataset-schema'd output ready to pipe into n8n, Google Sheets, Airtable, a CRM, or a lead-scoring workflow.

***

### Supported job boards, ATS platforms & sources

The API aggregates postings sourced from (among others):

**Major ATS / applicant tracking systems:** Greenhouse, Lever, Workday, SmartRecruiters, iCIMS, Ashby, BambooHR, Workable, Recruitee, Personio, Teamtailor, JazzHR, Breezy, Comeet, Jobvite, Taleo, SuccessFactors, Oracle, ADP, UKG, Paycom, Paylocity, Cornerstone, Avature, PageUp, Phenom, Eightfold, Gem, Jibe, JobScore, CATS One, Loxo, Bullhorn, Crelate, Manatal, OpenCATS, Freshteam, Hireology, HiBob, Factorial, Softgarden, TalentLyft, TalentHR, TalentAdore, Traffit, Trakstar, Huntflow, Hurma, PeopleForce, Enlizt, Quickin, Radancy, Rippling, Deel, NEOGOV, iSolved Hire, CareerPlug, Clinch, Compleo, Instaffo, Jobylon, JOIN, Pinpoint, Zoho Recruit, Get Manfred, GetOnBoard/Getonbrd, Getro, Vouch, Getmatch, and more.

**Major job boards & aggregators:** LinkedIn-style aggregation via Adzuna, Arbeitnow, WhatJobs, Reed, Bayt, GulfTalent, InfoJobs, USAJobs, Betterteam, ArbeitsAgentur, Jobnet, Jobdanmark, Jobtech, echojobs, aijobs, AI Jobs, Wellfound (Work at a Startup), We Work Remotely, RemoteOK, Remotive, Working Nomads, Himalayas, Jobicy, Jobspresso, FunctionalWorks, StartupAndVC, NoFluffJobs, JustJoin.it, Speedrun, Geekjob, TheHub, Jobstash, and more.

**Regional / CIS & Eastern Europe:** hh.ru, SuperJob, Avito Jobs, Rabota, Djinni, Habr Career, Zarplata, T-Bank (Tinkoff), SBER, VK, Yandex, Yandex Crowd, MTS, Domclick, 2GIS, Kuper, Lamoda, Ozon, TrudVsem, Erecruiter, ClevererStaff, CleverStaff, and more.

**Latin America:** Gupy, Vagas, Solides, InHire, GetManfred, and more.

**Nordics & EU:** ErgoJob/Jobnet, Emagine, Epam, DataArt, Luxoft, Itechart, Vention, BairesDev, Tecla, Lumenalta, Micro1, and more.

**Middle East / Gulf:** Bayt, GulfTalent, and more.

**APAC:** MyCareersFuture, WantedKR, and more.

**Company career sites & direct listings:** Apple, Google, Amazon, Uber, Oracle, ADP, Meta Careers, and thousands of individual company career pages parsed directly (schema.org/JSON-LD job postings, sitemaps, and structured career-page markup).

*(Full internal source taxonomy also includes generic structured-data ingestion sources — JSON-LD, schema.org markup, sitemap-based discovery, and direct career-page parsing — which is how the aggregator picks up postings from companies that don't use a named ATS at all.)*

> Filter results down to specific sources with the `source` input field if you only want, say, `greenhouse`, `lever`, and `workday` postings.

***

### Input

| Field | Type | Description |
|---|---|---|
| `queries` | array | One or more full-text search queries (title, company, description). Each runs as a separate search, results are merged and de-duplicated. Leave empty to fetch everything matching the filters below. |
| `descriptionFormat` | select | `html` | `text` | `markdown` |
| `sortBy` / `sortOrder` | select | Sort by `posted_at`, `created_at`, `salary_min`, `salary_max` |
| `regions` / `countries` / `cities` / `workMode` | dropdown / dropdown / free text / dropdown | Geography and remote/hybrid/onsite. `countries` is a searchable multi-select over all ISO 3166-1 codes. |
| `category`, `seniority`, `skills` | dropdown (`seniority`) / free text | Role filters |
| `domains`, `companyType` | array | Industry / company-type filters (fintech, startup, product, agency...) |
| `source` | array | Restrict to specific job boards/ATSs, e.g. `greenhouse`, `lever` |
| `postingLanguage` | array | ISO 639-1 language code(s) |
| `visaSponsorship` | checkbox | Only jobs offering visa sponsorship |
| `salaryCurrency`, `salaryMin`, `salaryMax` | — | Salary filters |
| `experienceYearsMin` | integer | Minimum years of experience required |
| `postedWithinDays` | integer | Only recently posted jobs |
| `maxItems` | integer | Overall cap on jobs scraped, shared across all queries |
| `fetchCompanyDetails` | boolean | Attach enriched `company_details` per job (deduplicated per company) |
| `companyFetchConcurrency` | integer | Parallelism for company lookups (default `5`) |
| `queryConcurrency` | integer | How many of your `queries` run in parallel (default `3`) |

***

### Output example

```json
{
    "public_slug": "assessor-de-investimentos-vitoria-es-valor-investimentos-assessoria-de-investimentos-ltda-kot4qt46",
    "source": "solides",
    "url": "https://valorinvestimentos.vagas.solides.com.br/vaga/896485",
    "title": "Assessor de Investimentos - Vitória ES",
    "description": "<p>O Assessor de Investimentos é um dos profissionais mais requisitados do mercado atual!</p>...",
    "company": "VALOR INVESTIMENTOS ASSESSORIA DE INVESTIMENTOS LTDA",
    "company_slug": "valor-investimentos-assessoria-de-investimentos-ltda",
    "location": "Vitória, ES",
    "company_website": "",
    "company_domains": ["fintech"],
    "company_types": ["startup"],
    "company_sizes": ["11-50"],
    "countries": ["es"],
    "regions": ["eu"],
    "work_mode": "onsite",
    "skills": [],
    "cities": ["Vitória"],
    "collections": [],
    "posted_at": "2026-08-04T00:00:00Z",
    "created_at": "2026-08-04T12:28:19Z",
    "updated_at": "2026-08-04T12:28:19Z",
    "closed_at": null,
    "enrichment": { "posting_language": "pt" },
    "enriched_at": null,
    "view_count": 0,
    "applied_count": 0,
    "company_details": {
        "slug": "valor-investimentos-assessoria-de-investimentos-ltda",
        "name": "VALOR INVESTIMENTOS ASSESSORIA DE INVESTIMENTOS LTDA",
        "job_count": 4,
        "regions": ["eu"],
        "countries": ["ES"],
        "domains": ["fintech"],
        "company_types": ["startup"],
        "company_sizes": ["11-50"]
    }
}
```

*(`company_details` only appears when `fetchCompanyDetails` is enabled.)*

***

### Use cases

- **Recruiting & sourcing** — pull fresh roles matching a client's target profile across hundreds of boards in one query.
- **Lead generation & sales intelligence** — turn active hiring signals (role, seniority, tech stack, company size, funding stage) into a scored outbound list.
- **Labor market & salary research** — analyze demand by role, region, seniority, or industry over time.
- **Competitor hiring analysis** — track what roles a competitor is opening and where.
- **Job board / remote-job aggregator products** — power a niche job board site or newsletter with a live, deduplicated feed.
- **n8n / automation workflows** — schedule this Actor and pipe fresh listings into Slack, Sheets, Airtable, or a CRM.

***

### How pagination, retries & multi-query concurrency work

The Actor pages through results in batches of up to 100 and stops automatically once every matching job has been fetched, `maxItems` is hit, or the API's `offset + limit ≤ 10000` deep-pagination ceiling is reached. If your query matches more than 10,000 jobs, narrow it with filters like `country`, `category`, or `postedWithinDays` to pull the rest in a follow-up run — the Actor will log a warning telling you exactly when this happens.

If you enter multiple `queries`, up to `queryConcurrency` of them run in parallel (each still paginates through its own results sequentially, since pages are order-dependent). Results are de-duplicated by job slug across queries, so overlapping searches never produce duplicate rows in your dataset.

Every request retries automatically on transient failures and `503`s with exponential backoff (500ms → 1s → 2s → 4s → …, with jitter so parallel workers don't retry in lockstep). `429` rate-limit responses honor the API's `Retry-After` header when present.

***

### Company enrichment & caching

When `fetchCompanyDetails` is on, the Actor calls `GET /companies/{slug}` to attach firmographic data to each job. Lookups are cached in memory by `company_slug` for the life of the run, so a company with 500 open roles in your result set is only fetched **once** — not 500 times — keeping the run fast and polite to the API.

***

### Related workflows

Pair this with a Google Maps or app-review scraper to cross-reference a company's hiring activity against its online presence, or feed the output straight into an n8n lead-scoring pipeline keyed on hiring velocity, company size, and industry domain.

# Actor input Schema

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

One or more full-text search queries (matched against title, company, and description). Each query is run as a separate search and results are merged into one dataset. Leave empty to fetch all jobs matching the filters below with no text query.

## `descriptionFormat` (type: `string`):

How the job description should be rendered in the output.

## `sortBy` (type: `string`):

Field to sort results by. Leave as default to get newest-first ordering.

## `sortOrder` (type: `string`):

Ascending or descending order for the sortBy field.

## `regions` (type: `array`):

Broad geographic regions to include.

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

Search and select one or more countries to restrict results to.

## `cities` (type: `array`):

Open vocabulary, exact city names as used by the source data, e.g. Berlin, Vitória.

## `workMode` (type: `array`):

Remote, hybrid, or on-site roles.

## `category` (type: `array`):

e.g. backend, frontend, devops, data\_science, product, sales ...

## `seniority` (type: `array`):

Experience level required for the role.

## `skills` (type: `array`):

Open vocabulary, e.g. go, rust, react

## `domains` (type: `array`):

fintech, crypto, ecommerce, gambling, gamedev, media, ...

## `companyType` (type: `array`):

product, startup, outsource, outstaff, agency, inhouse, government

## `salaryCurrency` (type: `string`):

Restrict salaryMin/salaryMax filtering to jobs listed in this currency.

## `salaryMin` (type: `integer`):

Only return jobs whose listed salary is at least this amount (in salaryCurrency, if set).

## `salaryMax` (type: `integer`):

Only return jobs whose listed salary is at most this amount (in salaryCurrency, if set).

## `experienceYearsMin` (type: `integer`):

Only return jobs requiring at least this many years of experience.

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

Only return jobs posted within the last N days. e.g. 2, 3

## `postingLanguage` (type: `array`):

ISO 639-1 language code(s) the job posting was written in, e.g. en, pt, de.

## `visaSponsorship` (type: `boolean`):

Only return jobs that offer visa sponsorship. Leave unchecked to include both sponsoring and non-sponsoring jobs.

## `source` (type: `array`):

Job board / ATS source, open vocabulary, e.g. greenhouse, lever, workday, solides.

## `fetchCompanyDetails` (type: `boolean`):

For each job's company, look up and attach a company\_details object (headcount, HQ country, industries, founding year, etc). Each unique company is only ever fetched once per run no matter how many of its jobs appear in the results.

## `companyFetchConcurrency` (type: `integer`):

How many company lookups to run in parallel when fetchCompanyDetails is on. Keep this modest to stay polite to the API.

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

Overall cap across all queries and pages. Leave empty to fetch everything matching the filters (bounded by the API's 10000 deep-paging limit per query).

## `queryConcurrency` (type: `integer`):

How many search queries (from the Search queries field) to run in parallel. Only relevant when you enter more than one query. Each query still paginates sequentially within itself.

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "descriptionFormat": "html",
  "sortBy": "posted_at",
  "sortOrder": "desc",
  "regions": [],
  "countries": [],
  "cities": [],
  "workMode": [],
  "category": [],
  "seniority": [],
  "skills": [],
  "domains": [],
  "companyType": [],
  "salaryCurrency": "",
  "postingLanguage": [],
  "visaSponsorship": false,
  "source": [],
  "fetchCompanyDetails": true,
  "companyFetchConcurrency": 5,
  "maxItems": 1000,
  "queryConcurrency": 3
}
```

# Actor output Schema

## `jobListings` (type: `string`):

All scraped job listings from freehire.me matching the search filters

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("code-node-tools/job-listings-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 = { "queries": ["software engineer"] }

# Run the Actor and wait for it to finish
run = client.actor("code-node-tools/job-listings-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 '{
  "queries": [
    "software engineer"
  ]
}' |
apify call code-node-tools/job-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,code-node-tools/job-listings-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/BLlbbaADJlUyZG6ax/builds/GxXKDIxUfdg8IiaVM/openapi.json