# Teamtailor Jobs Scraper & API: Any Career Site (`mrslm_data/teamtailor-jobs`) Actor

Scrape any Teamtailor career site, custom domains included: job title, department, role, city, country, remote status, date and description. CSV/JSON.

- **URL**: https://apify.com/mrslm_data/teamtailor-jobs.md
- **Developed by:** [MRSLM Data](https://apify.com/mrslm_data) (community)
- **Categories:** Jobs
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## Teamtailor Jobs Scraper & API: Any Career Site

**Open roles from any company's Teamtailor career site, custom domains included: department, role, city, country, remote status, date and description. $1.00 per 1,000 jobs.**

Teamtailor is an employer-branding and applicant tracking system used by thousands of companies, most of them in Sweden, Denmark, Norway, Finland and the rest of Europe. Many run their career site on their own domain (for example `jobs.company.com`), which is why generic scrapers miss them. This Actor accepts both the Teamtailor subdomain and the company's own careers URL, and returns every open role with department, role, city, country, remote status and posting date.

### What the Teamtailor Jobs Scraper does

You give it a list of companies that use Teamtailor for hiring: board names such as `lunar` or full careers URLs on `<name>.teamtailor.com` or a custom domain. For each company the Actor reads the public job feed that powers the company's own careers page, maps every open role to the same clean row format, applies your filters, and saves the result. One row per job.

There is no login, no browser and no proxy needed, because the feed is the same public list anyone sees on the careers site. That keeps runs fast (a few seconds for a handful of companies) and cheap.

The row format is shared with our other job-board Actors (Greenhouse, Lever, Workable, Personio, Rippling and the multi-platform ATS Jobs Scraper), so you can merge Teamtailor jobs with jobs from other platforms into one table without remapping columns.

### Who it is for

- **Recruiters and staffing agencies** who want to know the day a target company opens a role they can fill.
- **B2B sales teams** who use hiring as a buying signal: a company adding support or engineering staff is likely buying tools for them.
- **Investors and market analysts** who track hiring by team, city and seniority across a portfolio or a competitor set.
- **Job boards and newsletters** that need a clean, deduplicated feed from the companies they cover.
- **Job seekers** who want one sheet with every open role at their shortlist of employers.
- **Nordic market specialists** who track hiring at Swedish, Danish, Norwegian and Finnish companies, where Teamtailor is the most common careers platform.

### Quick start

1. Press **Start**. The form is already filled with this example input, so the first run returns real rows in under a minute:

```json
{
  "companies": [
    "https://career.teamtailor.com",
    "lunar"
  ],
  "maxJobsPerCompany": 10
}
```

2. Swap in your own values, or call the Actor through the Apify API, Make, Zapier, n8n or the Python/JS clients with the same JSON.
3. Download the results as JSON, CSV or Excel from the **Output** tab, or schedule the run to repeat.

### Real example: every open role at Teamtailor and Lunar

Run on 2 November 2026 with this input (no filters, all open jobs):

```json
{
  "companies": [
    "https://career.teamtailor.com",
    "lunar"
  ]
}
```

Result: **31 open jobs** in 4 seconds (Teamtailor: 17, Lunar: 14), charged as 31 job events, so the run cost about $0.031 plus the $0.00005 start fee.

- Top departments: Sales (4), Technology (4), FCP (4), CRM (3).
- Workplace type: on-site 18, hybrid 13.
- Countries: Denmark (14), Sweden (9), United States (2), Colombia (1).
- Newest posting in the run: 2026-10-30.

The six newest rows:

| Company | Title | Location | Workplace | Posted |
|---|---|---|---|---|
| Lunar | Platform Engineer | Aarhus, Denmark | on-site | 2026-10-30 |
| Teamtailor | Solution Architect (Bilingual French/English) | Stockholm, Sweden | hybrid | 2026-10-29 |
| Teamtailor | Head of Marketing - North America | Chicago, United States | hybrid | 2026-10-28 |
| Teamtailor | Strategic Partnerships Manager - Chicago | Chicago, United States | hybrid | 2026-10-28 |
| Lunar | Treasury Manager | Aarhus, Denmark | on-site | 2026-10-28 |
| Teamtailor | Account Executive - Bogota | Bogotá, Colombia | hybrid | 2026-10-27 |

To turn this into a weekly hiring report, keep the same input, add `"postedWithinDays": 7` and schedule it for Monday mornings: each run then returns only roles posted in the last week.

### Sample row (real run, trimmed)

```json
{
  "platform": "Teamtailor",
  "companyName": "Teamtailor",
  "title": "Senior Revenue Systems Administrator",
  "department": "CRM",
  "location": "Stockholm, Sweden",
  "country": "Sweden",
  "workplaceType": "on-site",
  "postedAt": "2026-10-14T12:53:31.000Z",
  "url": "https://career.teamtailor.com/jobs/8546174-senior-revenue-systems-administrator"
}
```

Every row also has: job ID, team, all locations, remote flag, update date, apply link, board link and scrape time, plus the full description when you turn it on. Platform extras: role, department, every location and the remote status (on-site, hybrid or remote).

### Output fields

| Field | What it holds |
|---|---|
| `platform` | Always the platform name, so merged tables stay traceable. |
| `company` | Board name (slug) you entered. |
| `companyName` | Company name shown on the board. |
| `jobId` | The platform job ID; stable across runs, use it to detect new and closed roles. |
| `title` | Job title. |
| `department` | Department, when the company sets one. |
| `team` | Teamtailor role, when set. |
| `location` | Primary location text. |
| `locations` | All locations listed for the job. |
| `country` | Country (code or name, as the platform gives it). |
| `workplaceType` | `remote`, `hybrid` or `on-site` when the company states it. |
| `isRemote` | True when the job is marked remote. |
| `employmentType` | Full-time, part-time, contract and similar, when set. |
| `seniority` | Experience level, when set. |
| `salary` | Salary range object (min, max, currency, period) when the company publishes it, else null. |
| `postedAt` | When the job was published (ISO 8601, UTC). |
| `updatedAt` | Last update time, when the platform gives it. |
| `url` | Public job ad URL. |
| `applyUrl` | Direct application URL, when different from the ad. |
| `boardUrl` | The careers board that was read. |
| `scrapedAt` | When this run read the job. |

With `includeDescription` on, each row also has `description`: the job ad as plain text, up to 5,000 characters, with e-mail addresses and phone numbers removed.

### Filters

- `titleKeywords` / `excludeTitleKeywords`: keep or drop jobs by words in the title (case-insensitive), e.g. keep `engineer, developer`, drop `intern, working student`.
- `locationKeywords`: match city, country or the location text, e.g. `Amsterdam`, `Germany`, `remote`.
- `departmentKeywords`: match the department or team, e.g. `engineering`, `sales`.
- `remoteOnly`: keep jobs marked remote, or whose location says remote.
- `postedWithinDays`: only jobs posted in the last N days.
- `maxJobsPerCompany` and `maxResults`: caps per company and per run. With `newestFirst` on (default), the cap keeps the newest jobs.

### Export to CSV, Excel, JSON or Google Sheets

Every run saves its rows to an Apify dataset. Open the **Output** tab and pick a format:

- **CSV** or **Excel** for spreadsheets and CRM imports. Nested fields (arrays and objects) are flattened into columns such as `locations/0`.
- **JSON** or **JSONL** to keep the nested structure for code and databases.
- **Google Sheets**: add the Apify "Google Sheets export" integration to the Actor or schedule, and every finished run is appended to a sheet.

You can also copy the dataset link from the **Storage** tab. It is a stable API URL your own scripts can download at any time.

### Use it from Make, Zapier or n8n

The Actor has official Apify modules in all three tools:

- **Make**: add the *Apify → Run an Actor* module, choose `mrslm_data/teamtailor-jobs`, paste the JSON input, then add *Apify → Get Dataset Items* and map the fields into Google Sheets, HubSpot, Airtable or Slack.
- **Zapier**: use the *Apify* app with the trigger *Finished Actor Run* (set up a schedule in Apify) or the action *Run Actor*, then *Fetch Dataset Items*.
- **n8n**: use the *Apify* node (Run Actor + Get dataset items), or a plain HTTP Request node calling the run-sync endpoint shown below.

### Schedule it

In Apify Console open **Schedules → Create new**, choose this Actor and a cron such as `0 7 * * 1-5` (07:00 every working day). With `postedWithinDays: 1` each daily run returns only the roles posted since the day before. Pair the schedule with an integration (e-mail, Slack, Google Sheets or a webhook) so new rows reach you without opening Apify.

### Call it from the API (Python, JavaScript or curl)

The input below is the same JSON you would paste into the form.

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("mrslm_data/teamtailor-jobs").call(run_input={
  "companies": [
    "https://career.teamtailor.com",
    "lunar"
  ],
  "titleKeywords": [
    "engineer"
  ],
  "postedWithinDays": 30
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**JavaScript / Node.js** (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('mrslm_data/teamtailor-jobs').call({"companies": ["https://career.teamtailor.com", "lunar"], "titleKeywords": ["engineer"], "postedWithinDays": 30});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'jobs');
```

**curl** (runs the Actor and returns the rows in one call, for runs under 5 minutes):

```bash
curl -X POST "https://api.apify.com/v2/acts/mrslm_data~teamtailor-jobs/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>&format=csv" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["https://career.teamtailor.com", "lunar"], "titleKeywords": ["engineer"], "postedWithinDays": 30}'
```

### Use it from AI agents and chat assistants (MCP)

Apify's MCP server (`https://mcp.apify.com`) exposes Store Actors as tools for Claude, ChatGPT, Cursor and other MCP clients. Add the server with your Apify token, enable `mrslm_data/teamtailor-jobs`, and ask in plain language, for example: *"List every open engineering job at Teamtailor and Lunar posted in the last 30 days."* The assistant fills the input, runs the Actor and reads the rows back. You pay the same per-job price as a normal run.

### What it costs

- **Job: $1.00 per 1,000 saved** (Silver $0.90, Gold $0.80)
- Plus $0.00005 per run. You pay only for jobs saved after your filters. Companies that are not found, and jobs your filters drop, are free.

Worked example: 200 companies with an average of 15 open roles each is 3,000 jobs, or about **$3.00** per full run on the free tier price. With `postedWithinDays: 7` the same weekly run usually saves a few hundred jobs, well under $1. Apify's free plan includes monthly platform credit, which covers small runs like the example above.

### Tips

- **Find the board name fast.** Open the company's careers page and look at the address bar or the "Apply" link. The part before the platform domain is the board name.
- **Keep runs cheap.** Use `titleKeywords`, `locationKeywords` or `postedWithinDays` so only the jobs you need are saved and charged. Jobs your filters drop are free.
- **Watch many companies at once.** Paste dozens or hundreds of boards in one run. Boards that do not exist are logged and skipped at no charge.
- **Track changes.** Schedule a daily run and compare `jobId` values with yesterday's dataset to see which roles opened and closed.
- **Descriptions only when needed.** `includeDescription` adds up to 5,000 characters per job. Leave it off for lead lists and dashboards; turn it on for keyword or skills analysis.

### Limits

- Only **public** job ads are returned: the roles the company itself lists on its Teamtailor careers site. Internal-only postings and closed jobs are not in the feed.
- Salary, seniority and employment type appear only when the company fills them in; otherwise they are `null`.
- Teamtailor does not publish salary, seniority or employment type in its public feed, so those fields are usually `null`. Use the description for those details.
- A company that moves to another applicant tracking system disappears from Teamtailor. Use our ATS Jobs Scraper to auto-detect the platform for a list of companies.

### FAQ

**Where does the data come from?** From the company's public Teamtailor job board feed: the same list of open roles the company shows on its careers page.

**Does it include recruiter or applicant data?** No. Only the public job ad. Email addresses and phone numbers in descriptions are removed.

**How fresh is it?** Live. Each run reads the board at that moment, so closed jobs disappear and new ones appear.

**Does it work with custom career domains?** Yes. Paste the career site URL, for example `https://career.teamtailor.com`. The Actor reads the same public jobs feed that site uses.

**Why are some countries spelled out and others coded?** `country` is passed through as Teamtailor gives it, usually the full country name.

**Can I scrape all Teamtailor companies at once?** No. Teamtailor does not publish a directory of customers, so you supply the companies. Most users start from a target-account list or a list of companies in a sector.

**What happens if a board name is wrong?** The Actor logs it, skips it and charges nothing for it. The rest of the run continues.

### Data source and freshness

Each run reads the company's public Teamtailor job feed at that moment, so new roles appear and closed roles disappear on the next run. Nothing is cached between runs.

### Is it legal?

This Actor only reads pages and feeds that the website itself publishes to every visitor without a login. It obeys each site's robots.txt, keeps a polite request rate, and never tries to get past logins, paywalls, captchas or bot checks. It does not collect personal data such as emails, phone numbers or names of private individuals. You are responsible for how you use the data: follow the source site's terms, copyright and the privacy laws that apply to you (GDPR, CCPA, etc.). This tool is independent and not affiliated with or endorsed by the platforms it reads.

# Actor input Schema

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

Teamtailor board URLs or names. One per line. Leave empty to run the example search (https://career.teamtailor.com, lunar, 10 jobs each).

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

Keep jobs whose title contains any of these words (e.g. engineer, sales). Empty = all jobs.

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

Drop jobs whose title contains any of these words (e.g. intern).

## `locationKeywords` (type: `array`):

Keep jobs whose location or country contains any of these (e.g. London, Germany, remote).

## `departmentKeywords` (type: `array`):

Keep jobs whose department or team contains any of these (e.g. engineering).

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

Keep only jobs marked remote.

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

Keep only jobs posted in the last N days. 0 = any date.

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

Add the full job description as plain text (up to 5,000 characters). Makes rows larger.

## `newestFirst` (type: `boolean`):

Sort each company's jobs by posting date, newest first (so per-company limits keep the newest).

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

0 = all open jobs.

## `maxResults` (type: `integer`):

Safety cap on saved jobs across the whole run. 0 = no cap. Your max cost per run is always respected.

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

Usually not needed.

## Actor input object example

```json
{
  "companies": [
    "https://career.teamtailor.com",
    "lunar"
  ],
  "remoteOnly": false,
  "postedWithinDays": 0,
  "includeDescription": false,
  "newestFirst": true,
  "maxJobsPerCompany": 10,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All jobs as a dataset (JSON, CSV, Excel and more via the API or Console).

## `summary` (type: `string`):

Jobs per board, boards that failed, and the stop reason.

# 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 = {
    "companies": [
        "https://career.teamtailor.com",
        "lunar"
    ],
    "maxJobsPerCompany": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrslm_data/teamtailor-jobs").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 = {
    "companies": [
        "https://career.teamtailor.com",
        "lunar",
    ],
    "maxJobsPerCompany": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("mrslm_data/teamtailor-jobs").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 '{
  "companies": [
    "https://career.teamtailor.com",
    "lunar"
  ],
  "maxJobsPerCompany": 10
}' |
apify call mrslm_data/teamtailor-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrslm_data/teamtailor-jobs"
        }
    }
}
```

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/bKJhY0M3E7zaLVlE4/builds/ogiu0Y7wG6EGBdwUf/openapi.json