# SmartRecruiters Jobs Scraper (`fetch_cat/smartrecruiters-jobs-scraper`) Actor

Scrape public SmartRecruiters job postings by company with details and apply URLs.

- **URL**: https://apify.com/fetch\_cat/smartrecruiters-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

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

## SmartRecruiters Jobs Scraper

Collect public job postings from SmartRecruiters-powered career pages.

Use this actor when you need structured hiring data from companies that publish roles through SmartRecruiters. Provide company names or career page URLs, choose how many jobs you want, and export clean records with titles, locations, departments, job links, apply links, descriptions, and posting dates.

### What does SmartRecruiters Jobs Scraper do?

SmartRecruiters Jobs Scraper turns public SmartRecruiters career pages into a structured dataset.

It helps you:

- 🧲 Monitor open roles at target companies
- 📈 Track hiring trends by department, location, and remote status
- 🧾 Export job descriptions for analysis
- 🔎 Build recruiting, sales, or labor-market workflows
- 🔗 Collect public job and apply links in one table

### Who is it for?

This actor is useful for several teams.

- Recruiters tracking competitor hiring
- Sales teams looking for buying signals
- Labor-market analysts monitoring demand
- Job-board operators collecting public roles
- RevOps teams enriching account research
- Founders watching where companies are investing

### Why use it?

SmartRecruiters career pages are common across enterprise hiring teams. Manually checking every company page is slow and easy to forget.

This actor gives you repeatable exports that can run on a schedule, feed a CRM, power a job board, or support market research.

### Typical use cases

- Track new jobs at a list of target accounts
- Watch which departments are growing
- Find companies hiring for a specific role family
- Export remote roles for a job-alert workflow
- Build datasets for hiring trend dashboards
- Enrich company profiles with current open roles

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost (init, proxy warmup, first HTTP setup). | $0.005 |
| `result` | Charged per result extracted. | $0.000034 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Input options

You can provide company names, career page URLs, or both.

| Input | Type | Description |
| --- | --- | --- |
| `companyIdentifiers` | array | SmartRecruiters company slugs such as `SmartRecruiters` |
| `companyUrls` | array | SmartRecruiters career page URLs |
| `limit` | integer | Maximum jobs to save across all companies |
| `includeDetails` | boolean | Include descriptions and apply links when available |
| `maxConcurrency` | integer | Number of parallel detail requests |

### Reliability and limits

- This Actor reads public SmartRecruiters company posting boards only. It does not require a login, collect applications, or use browser automation.
- A missing company board fails clearly when every requested company is unavailable. A real but empty public board completes with zero job rows and a `RUN_SUMMARY` record.
- Large exports save rows progressively. When the platform deadline approaches, the Actor stops admitting new requests and stores the remaining company and offset in `PENDING_WORK`.
- Job descriptions are optional. If one detail record is temporarily unavailable, the base list record is still exported with a run warning.

### Example input

```json
{
  "companyIdentifiers": ["SmartRecruiters"],
  "limit": 25,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

### Company names and URLs

The simplest input is a SmartRecruiters company slug.

For example, if the public career page is:

```text
https://jobs.smartrecruiters.com/SmartRecruiters
```

Use:

```json
{
  "companyIdentifiers": ["SmartRecruiters"]
}
```

You can also paste the career page URL into `companyUrls`.

### Output data

Each dataset row is one public job posting.

| Field | Description |
| --- | --- |
| `jobId` | SmartRecruiters job identifier |
| `refNumber` | Employer reference / requisition number |
| `title` | Job title |
| `company` | Company name |
| `department` | Department when available |
| `function` | Job function when available |
| `location` | Full location string |
| `remote` | Remote-work flag when available |
| `hybrid` | Hybrid-work flag when available |
| `employmentType` | Employment type when available |
| `experienceLevel` | Experience level when available |
| `language` | Job ad language when available |
| `postedDate` | Public posting date |
| `applyUrl` | Apply link |
| `jobUrl` | Public job page link |
| `descriptionText` | Plain-text job description |
| `descriptionHtml` | HTML job description |
| `sourceCompanySlug` | Company slug used for the scrape |
| `scrapedAt` | Timestamp when the job was saved |

### Example output item

```json
{
  "jobId": "744000132998500",
  "refNumber": "REF2010Z",
  "title": "Senior Information Security Specialist",
  "company": "SmartRecruiters Inc",
  "department": "Engineering",
  "function": "Engineering",
  "location": "Poland, REMOTE, Poland",
  "remote": true,
  "hybrid": false,
  "employmentType": "Full-time",
  "experienceLevel": "Mid-Senior Level",
  "language": "English",
  "postedDate": "2026-06-19T06:46:31.452Z",
  "applyUrl": "https://jobs.smartrecruiters.com/smartrecruiters/...",
  "jobUrl": "https://jobs.smartrecruiters.com/smartrecruiters/...",
  "descriptionText": "SmartRecruiters is looking for...",
  "descriptionHtml": "<p>SmartRecruiters is looking for...</p>",
  "sourceCompanySlug": "SmartRecruiters",
  "scrapedAt": "2026-06-23T14:30:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Add one or more SmartRecruiters company names or career URLs.
3. Set **Maximum jobs** to the number of postings you want.
4. Keep **Include job descriptions** enabled if you need full job text.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for best results

- Start with one company and a small limit to confirm the slug.
- Use company URLs if you are unsure about the exact slug.
- Increase the limit for scheduled monitoring runs.
- Keep descriptions enabled for analysis workflows.
- Disable descriptions when you only need a fast list of titles and URLs.

### Scheduling

You can run this actor on a schedule.

Common schedules include:

- Daily checks for new jobs
- Weekly hiring trend snapshots
- Monthly account enrichment exports

Scheduled runs are useful when you want to detect new openings without manually checking career pages.

### Integrations

The dataset can be sent to many tools.

- Google Sheets for lightweight monitoring
- Airtable for recruiting operations
- CRM systems for sales triggers
- BI dashboards for hiring analytics
- Webhooks for alerts when new jobs appear
- Data warehouses for trend analysis

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/smartrecruiters-jobs-scraper').call({
  companyIdentifiers: ['SmartRecruiters'],
  limit: 25,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/smartrecruiters-jobs-scraper').call(run_input={
    'companyIdentifiers': ['SmartRecruiters'],
    'limit': 25,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~smartrecruiters-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"companyIdentifiers":["SmartRecruiters"],"limit":25,"includeDetails":true}'
```

### MCP usage

Use Apify MCP to run this actor from AI tools.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/smartrecruiters-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-smartrecruiters-jobs "https://mcp.apify.com/?tools=fetch_cat/smartrecruiters-jobs-scraper"
```

JSON MCP server configuration:

```json
{
  "mcpServers": {
    "apify-smartrecruiters-jobs": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/smartrecruiters-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Run SmartRecruiters Jobs Scraper for SmartRecruiters and summarize open engineering roles."
- "Find remote jobs from this SmartRecruiters company page and export them as a table."
- "Compare current job postings with last week's dataset and list new roles."

### Data freshness

The actor reads public career page data at run time. Each item includes `scrapedAt`, so you can compare exports over time.

### Limits

The actor can save up to the limit you set. If a company has fewer public jobs than your limit, the run finishes after collecting all available jobs.

### Empty results

An empty dataset usually means one of these things:

- The company slug is misspelled
- The company is not hosted on SmartRecruiters
- The company currently has no public jobs
- The career page URL is not a SmartRecruiters URL

Try pasting the full company career URL if the slug is unclear.

### Troubleshooting

#### Why did I get fewer jobs than my limit?

The company may have fewer public postings than your requested maximum. The limit is a cap, not a guarantee.

#### Why is a field empty?

Not every company fills every SmartRecruiters field. Department, employment type, remote status, and descriptions depend on what the company publishes.

#### Can I scrape private or internal jobs?

No. This actor is designed for public job postings only.

### Legality

This actor collects publicly available job posting data. You are responsible for using the data legally and respecting applicable laws, terms, and privacy rules. Do not use it to collect private, internal, or access-restricted content.

### Related scrapers

You may also find these useful:

- https://apify.com/fetch\_cat/greenhouse-jobs-scraper
- https://apify.com/fetch\_cat/lever-jobs-scraper
- https://apify.com/fetch\_cat/ashby-jobs-scraper
- https://apify.com/fetch\_cat/workday-jobs-scraper

### FAQ

#### Does this actor need my SmartRecruiters login?

No. It only collects public job postings.

#### Can I run multiple companies at once?

Yes. Add multiple values to `companyIdentifiers` or `companyUrls`.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, and more.

#### Can I monitor new jobs over time?

Yes. Schedule the actor and compare datasets by `jobId` and `scrapedAt`.

#### Does it include apply links?

Yes, when available from the public posting data.

#### Does it include full descriptions?

Yes, keep `includeDetails` enabled to save `descriptionText` and `descriptionHtml`.

# Actor input Schema

## `companyIdentifiers` (type: `array`):

SmartRecruiters company identifiers, for example `SmartRecruiters`, `Bosch`, or `Wolt`. Use the slug from the company's SmartRecruiters career URL.

## `companyUrls` (type: `array`):

Optional SmartRecruiters career page or API URLs. Examples: `https://jobs.smartrecruiters.com/SmartRecruiters` or `https://api.smartrecruiters.com/v1/companies/SmartRecruiters/postings`.

## `limit` (type: `integer`):

Maximum number of job postings to save across all companies.

## `includeDetails` (type: `boolean`):

Fetch each public posting detail record to include apply URLs and description HTML/text. Disable for faster list-only runs.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent detail API requests.

## `maxRuntimeSeconds` (type: `integer`):

Optional time cap for this export. The Actor stops admitting new requests before this cap, saves completed jobs, and records remaining work for a later resume. It never extends the platform timeout.

## Actor input object example

```json
{
  "companyIdentifiers": [
    "SmartRecruiters"
  ],
  "companyUrls": [],
  "limit": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `runSummary` (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 = {
    "companyIdentifiers": [
        "SmartRecruiters"
    ],
    "companyUrls": [],
    "limit": 20,
    "includeDetails": true,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/smartrecruiters-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 = {
    "companyIdentifiers": ["SmartRecruiters"],
    "companyUrls": [],
    "limit": 20,
    "includeDetails": True,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/smartrecruiters-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 '{
  "companyIdentifiers": [
    "SmartRecruiters"
  ],
  "companyUrls": [],
  "limit": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}' |
apify call fetch_cat/smartrecruiters-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Dh5tsdUsj7DzrpLM4/builds/Mad05pfyCcOsfhZmr/openapi.json