# Recruitee Jobs Scraper (`devilscrapes/recruitee-jobs-scraper`) Actor

Scrape every job posting from any Recruitee-hosted employer career site via Recruitee's own public, unauthenticated JSON API, no login or browser required. One request per company returns titles, locations, salary, and full HTML descriptions.

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

## Pricing

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

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Recruitee Jobs Scraper

**💰 $1.50 / 1 000 results**  ·  pay only for results  ·  no credit card to try

*We do the dirty work so your dataset stays clean.* 😈

Scrape every job posting from any Recruitee-hosted employer career site via Recruitee's own public JSON API — no login, no browser, no API key. Give it a list of company subdomains and get titles, locations, salary, and optional full HTML descriptions as clean typed rows.

</div>

***

### 🎯 What this scrapes

Every employer whose career site lives at `{company}.recruitee.com` is served by the same public, unauthenticated JSON endpoint. This Actor talks to it directly: hand it one or more company identifiers — the subdomain in that employer's board URL, e.g. `auditdata` — and it fetches the entire current job board in a single request per company, normalizing every posting into one clean row schema. One scraper, every Recruitee employer.

### 🔥 Features

- 🔑 **Keyless public API** — no OAuth, no token, no per-company setup; the same endpoint the careers page itself calls.
- ⚡ **One request per company** — Recruitee's list endpoint already inlines the full HTML description, so there's no second per-posting fetch to orchestrate.
- 🏢 **Multi-company in one run** — pass many company identifiers; rows come back identically shaped, tagged with `company_id` / `company_name`.
- 💵 **Salary when published** — numeric-string `salary.min`/`salary.max` values are parsed into clean floats, currency and period included.
- 📝 **Optional full descriptions** — flip `includeDescription` on for the complete HTML posting body at no extra request cost, or off for a leaner payload.
- 🧊 **Clean, typed rows** — Pydantic-validated, ISO-8601 timestamps, stable IDs. Export JSON / CSV / Excel straight from the Apify Console.

### 💡 Use cases

- **Recruiting & talent intelligence** — track what a target employer is hiring for, where, and in which departments.
- **Job-board aggregation** — add Recruitee coverage next to Workday / SmartRecruiters / Greenhouse / Lever / Ashby in one pipeline.
- **Labor-market research** — sample hiring demand across an industry by role, category, or location.
- **Competitive hiring intel** — watch a competitor's open reqs, including salary bands where published, to infer team growth and direction.
- **ATS data pipelines** — wire structured job rows into your CRM, dashboard, or n8n / Make workflow on a schedule.

### ⚙️ How to use it

1. Click **Try for free** at the top of the Store listing.
2. Add one or more **Company IDs** — the subdomain from a `{company}.recruitee.com` careers URL (e.g. `auditdata`).
3. Optionally set **Max results per company** and toggle **Include description**.
4. Click **Start**. Rows stream into the dataset as each company's board is fetched.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or pull via the Apify API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `companyIds` | `array` | ✅ | — | Recruitee company subdomains (the `{company}` in `{company}.recruitee.com`, e.g. `auditdata`), or full board URLs. |
| `maxResultsPerCompany` | `integer` | no | `100` | Client-side cap on rows emitted per company. |
| `includeDescription` | `boolean` | no | `false` | Emit each posting's full HTML description (already fetched in the same request either way). |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Apify Proxy configuration. |

#### Example input

```json
{
  "companyIds": ["auditdata"],
  "maxResultsPerCompany": 25,
  "includeDescription": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### 📤 Output

One dataset item per job posting. `description_html` is populated only when `includeDescription` is on.

| Field | Type | Notes |
|---|---|---|
| `job_id` | `integer` | Stable numeric Recruitee offer id. |
| `guid` | `string` | Additional stable identifier. |
| `slug` | `string` | URL path segment. |
| `title` | `string` | Job title. |
| `company_id` | `string` | Company identifier you supplied. |
| `company_name` | `string` | Employer display name. |
| `department` | `string \| null` | Department, when published. |
| `category_code` | `string \| null` | Recruitee category code. |
| `employment_type_code` | `string \| null` | e.g. `fulltime_permanent`. |
| `experience_code` | `string \| null` | e.g. `experienced`. |
| `education_code` | `string \| null` | e.g. `bachelor_degree`. |
| `city` | `string \| null` | Posting city. |
| `country` | `string \| null` | Posting country. |
| `country_code` | `string \| null` | ISO country code. |
| `remote` / `hybrid` / `on_site` | `boolean` | Work-arrangement flags. |
| `salary_min` / `salary_max` | `float \| null` | Parsed from Recruitee's numeric-string salary fields. |
| `salary_period` | `string \| null` | e.g. `"year"` or `"hour"`. |
| `salary_currency` | `string \| null` | e.g. `"USD"`. |
| `description_html` | `string \| null` | Full posting body **(when `includeDescription` is on)**. |
| `careers_url` | `string` | Canonical posting URL. |
| `careers_apply_url` | `string` | Apply URL. |
| `published_at` | `string \| null` | ISO-8601 publish timestamp. |
| `updated_at` | `string` | ISO-8601 last-updated timestamp. |
| `scraped_at` | `string` | UTC ISO-8601 fetch timestamp. |

#### Example output

```json
{
  "job_id": 2680730,
  "guid": "dl9ua",
  "slug": "data-architect",
  "title": "Data Architect",
  "company_id": "auditdata",
  "company_name": "Auditdata",
  "department": "R&D",
  "category_code": "information_technology",
  "employment_type_code": "fulltime_permanent",
  "experience_code": "experienced",
  "education_code": "bachelor_degree",
  "city": "remote",
  "country": "Poland",
  "country_code": "PL",
  "remote": true,
  "hybrid": false,
  "on_site": false,
  "salary_min": null,
  "salary_max": null,
  "salary_period": null,
  "salary_currency": null,
  "description_html": "<h4>...</h4><p>... HTML string ...</p>",
  "careers_url": "https://auditdata.recruitee.com/o/data-architect",
  "careers_apply_url": "https://auditdata.recruitee.com/o/data-architect/c/new",
  "published_at": "2026-07-21T07:48:42+00:00",
  "updated_at": "2026-07-21T07:48:42+00:00",
  "scraped_at": "2026-07-26T15:00:00+00:00"
}
```

### 💰 Pricing

Pay-Per-Event — you're charged only when these fire:

| Event | USD | What it covers |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up per run |
| `result` | $0.0015 | Per job posting written to the dataset |

**Example**: 1 000 postings ≈ **$1.51**. No subscription, no minimum, no card to start — Apify gives every new account $5 of free credit.

### 🚧 Limitations

- **Public postings only** — the openly published careers boards, not authenticated internal/employee views.
- **Company IDs, not company names** — you supply the Recruitee subdomain from the careers URL; a display name like "Auditdata" may differ from its actual identifier.
- **No board-side pagination observed** — every sampled company returns its full board in one response; an unusually large board is fetched as-is, whatever the single response contains.
- **Point-in-time snapshot** — returns the board as it stands now; schedule recurring runs to track changes.

### ❓ FAQ

**Do I need a Recruitee account or API key?**

No — every field comes from Recruitee's own public offers API, the same one the careers page calls.

**How do I find a company's ID?**

It's the subdomain in the careers URL: `https://{company}.recruitee.com`. Paste that `{company}` (e.g. `auditdata`).

**Can one run cover several employers?**

Yes — put multiple identifiers in `companyIds` and every row comes back identically shaped, tagged with `company_id` / `company_name`.

**Is this legal?**

We fetch public, unauthenticated job-posting data that employers publish for candidates. No login, no private endpoints.

### 💬 Your feedback

Spotted a bug, hit a company that behaves differently, or need an extra field? Open an issue on the Actor's **Issues** tab in Apify Console — we ship fixes weekly and read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `companyIds` (type: `array`):

Recruitee company subdomain, e.g. "auditdata" (the {company} in {company}.recruitee.com), or a full board URL — the subdomain is regex-extracted automatically. A plain string with no "recruitee.com" substring is used literally, unchanged (including case).

## `maxResultsPerCompany` (type: `integer`):

Cap job postings emitted per companyIds entry. A client-side slice of the single response array, not server-side pagination.

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

When enabled, emit the full job description (HTML) already returned in the single company request. Does not add any extra HTTP calls either way.

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

Apify Proxy configuration. No anti-bot behaviour has been observed on Recruitee's public API, so the standard (non-residential) group is enough.

## Actor input object example

```json
{
  "companyIds": [
    "auditdata"
  ],
  "maxResultsPerCompany": 100,
  "includeDescription": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "companyIds": [
        "auditdata"
    ],
    "maxResultsPerCompany": 100,
    "includeDescription": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/recruitee-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 = {
    "companyIds": ["auditdata"],
    "maxResultsPerCompany": 100,
    "includeDescription": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/recruitee-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companyIds": [
    "auditdata"
  ],
  "maxResultsPerCompany": 100,
  "includeDescription": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/recruitee-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=devilscrapes/recruitee-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cMOD9sM1gsCkWvhA0/builds/KxZRn89kCp7OHQCiF/openapi.json
