# Karriere.at Austrian Jobs Scraper (`parsebird/karriere-at-jobs-scraper`) Actor

Scrape jobs from karriere.at: titles, salaries, companies, locations, remote flags, and full descriptions. Search by keyword, location, or paste a search URL.

- **URL**: https://apify.com/parsebird/karriere-at-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 1,000 job scrapeds

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

### Karriere.at Austrian Jobs Scraper

Extract job listings from [karriere.at](https://www.karriere.at), Austria's largest job platform, without writing a single line of scraping code. The **Karriere.at Austrian Jobs Scraper** searches by keyword, location, or a pasted search URL, and returns clean, structured job data — titles, salaries, companies, locations, remote flags, and full descriptions — ready for analysis, monitoring, or integration into your own job board or ATS.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by keyword, location, and radius, pull structured salary and apply-URL data from every listing, track a search over time with incremental mode, and get new jobs pushed straight to Telegram, Slack, Discord, WhatsApp, or your own webhook.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/karriere-at-jobs-scraper. Scrapes job listings from karriere.at (Austria's largest job platform). Call via ApifyClient: client.actor("parsebird/karriere-at-jobs-scraper").call(run_input={"query": "software engineer", "location": "wien", "maxResults": 50, "includeDetails": true}). Also accepts startUrls (paste a karriere.at /jobs search URL directly), radius, remoteOnly, compact (core fields only), descriptionFormat ("all"/"text"/"html"/"markdown"), incrementalMode + stateKey (emit only NEW/CHANGED/EXPIRED jobs across runs), skipReposts, and notification channels (telegramToken/telegramChatId, discordWebhookUrl, slackWebhookUrl, whatsappPhoneNumberId/whatsappAccessToken/whatsappTo, webhookUrl). Returns per job: jobId, title, company, companySlug, companyUrl, companyEmployees, companyLogoUrl, location, addressRegion, isRemote, salaryText, salaryMin, salaryMax, salaryCurrency, salaryPeriod, employmentType, jobLevel, description (or descriptionText/descriptionHtml/descriptionMarkdown), url, applyUrl, directApply, postedDate, portalUrl, scrapedAt, source. Full API spec: https://apify.com/parsebird/karriere-at-jobs-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```

### What does Karriere.at Austrian Jobs Scraper do?

This actor queries karriere.at's own job search endpoint directly — no browser rendering, no fragile CSS selectors. You give it a search term, a location, or a karriere.at search URL, and it returns every matching job with salary, employment type, remote-work flag, company details, and (optionally) the full job description and apply link.

- 🔍 **Keyword, location, and radius search** — search by job title or free text, narrow to a city or region, and set a search radius in kilometers.
- 🔗 **Paste-a-URL mode** — copy a search URL straight from your browser (with filters already applied) and the actor parses `keywords`, `locations`, `radius`, and `homeoffice` from it automatically.
- 📋 **Full job details on request** — structured salary (min/max/currency/period), employment type, job level, address region, apply URL, and direct-apply detection, sourced from karriere.at's own structured job-posting data.
- ✂️ **Flexible description output** — plain text, HTML, Markdown, or all three, with optional character-length truncation for LLM token budgets.
- 📦 **Compact mode** — a lean, core-fields-only shape built for AI-agent and MCP workflows.
- ♻️ **Incremental tracking** — re-run the same search on a [schedule](https://docs.apify.com/platform/schedules) and only get NEW, CHANGED, REAPPEARED, or EXPIRED listings back, keyed by a stable state per search.
- 🚫 **Repost detection** — flags and optionally excludes listings that look like a repost of a job you've already seen (same title, company, and location under a new job ID).
- 🔔 **Built-in alerts** — send new/changed jobs to Telegram, Discord, Slack, WhatsApp, or a generic webhook for n8n/Make/Zapier, with no extra automation needed.

### What data can you extract from karriere.at?

| Field | Description |
|-------|-------------|
| `title` | Job title as posted |
| `company` / `companySlug` / `companyUrl` / `companyEmployees` / `companyLogoUrl` | Hiring company details |
| `location` / `addressRegion` | City/region and Austrian federal state |
| `isRemote` | Whether the listing offers a home-office option |
| `salaryText` / `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` | Salary as displayed and as structured data, where disclosed |
| `employmentType` / `jobLevel` | e.g. `Vollzeit`, `Teilzeit`; `Berufseinstieg`, `Berufserfahrung` |
| `description` / `descriptionText` / `descriptionHtml` / `descriptionMarkdown` | Full job description, in the format(s) you choose |
| `applyUrl` / `directApply` | Where to apply and whether it's a direct/smart-apply listing |
| `postedDate` / `postedDateRelative` | ISO publish date (from full details) and karriere.at's own relative label |
| `url` | Canonical karriere.at job URL |
| `changeStatus` | `NEW` / `CHANGED` / `UNCHANGED` / `REAPPEARED` / `EXPIRED` — only present when Incremental Mode is on |

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `query` | string | No | — | Search term (e.g. `"developer"`). Aliases: `searchQuery`, `keyword`, or `keywords` as a string/array — array entries each run as a separate search and are merged/deduplicated |
| `startUrls` | array | No | — | karriere.at search URLs to parse directly instead of/alongside `query` — either a query-string search or a `/jobs/<location>` URL |
| `location` | string | No | — | City or region, e.g. `"wien"`, `"graz"`, `"salzburg"` |
| `radius` | string | No | — | Search radius in km: `0`, `10`, `20`, `30`, `50` |
| `remoteOnly` | boolean | No | `false` | Only return jobs with a home-office option |
| `maxResults` | integer | No | `25` | Maximum total results (0 = unlimited, capped at 5000) |
| `includeDetails` | boolean | No | `true` | Fetch full details (description, structured salary, apply URL) per job |
| `descriptionFormat` | string | No | `all` | `all`, `text`, `html`, or `markdown` |
| `descriptionMaxLength` | integer | No | `0` | Truncate description to N characters (0 = no truncation) |
| `compact` | boolean | No | `false` | Core fields only, for AI-agent/MCP workflows |
| `excludeEmptyFields` | boolean | No | `false` | Drop null/empty fields from each record before push |
| `incrementalMode` | boolean | No | `false` | Only emit new/changed jobs since the last run with this `stateKey` |
| `stateKey` | string | No | auto-derived | Stable identifier for the tracked search; auto-derived from your search inputs if left empty |
| `skipReposts` | boolean | No | `false` | Exclude listings detected as reposts of previously seen jobs |
| `emitUnchanged` / `emitExpired` | boolean | No | `false` | Also emit UNCHANGED / EXPIRED listings in incremental mode |
| `telegramToken` / `telegramChatId` | string | No | — | Telegram bot alerts |
| `discordWebhookUrl` | string | No | — | Discord webhook alerts |
| `slackWebhookUrl` | string | No | — | Slack webhook alerts |
| `whatsappPhoneNumberId` / `whatsappAccessToken` / `whatsappTo` | string | No | — | WhatsApp Cloud API alerts |
| `webhookUrl` / `webhookHeaders` | string / object | No | — | Generic webhook receiving the full job payload + run metadata |
| `notificationLimit` | integer | No | `5` | Max jobs listed per notification message (1–20) |
| `notifyOnlyChanges` | boolean | No | `false` | With Incremental Mode, only notify on NEW/CHANGED/REAPPEARED jobs |
| `appConnector` / `mcpIssueTeam` | string | No | — | Send a run summary to a connected app (e.g. Notion) via Apify integrations |

### Output example

```json
{
  "jobId": "10010591",
  "title": "IT-Support (m/w/d)",
  "company": "Aichelin GesmbH",
  "companySlug": "aichelin",
  "companyUrl": "http://www.aichelin.at",
  "companyEmployees": "51 - 100",
  "companyLogoUrl": "https://kcdn.at/company/8281/3387884/aichelin-ifs-logo-farbig-ppt_web.companysquare.png",
  "location": "Mödling",
  "addressRegion": "Niederösterreich",
  "isRemote": true,
  "salaryText": "ab 3.396,21 € monatlich",
  "salaryMin": 3396.21,
  "salaryCurrency": "EUR",
  "salaryPeriod": "MONTH",
  "employmentType": "Vollzeit",
  "jobLevel": "Berufserfahrung",
  "description": "<p>Als Technologieführer mit hoher Wärmebehandlungskompetenz haben wir uns...</p>",
  "url": "https://www.karriere.at/jobs/10010591",
  "applyUrl": "https://bewerben.karriere.at/9dKs2qV3",
  "directApply": true,
  "postedDate": "2026-03-29T00:00:00+01:00",
  "portalUrl": "https://www.karriere.at",
  "scrapedAt": "2026-04-04T10:59:55.809Z",
  "source": "karriere.at"
}
```

Download results as **JSON, CSV, Excel, HTML, or XML** directly from the Apify Console, or fetch them via the [Apify API](https://docs.apify.com/api/v2) / [dataset endpoint](https://apify.com/parsebird/karriere-at-jobs-scraper/api).

### Use cases

- **Job board aggregation** — feed a niche job board, newsletter, or Slack/Discord bot with fresh Austrian listings filtered by keyword and location.
- **Job alerts** — pair `incrementalMode` with a [schedule](https://docs.apify.com/platform/schedules) and Telegram/Slack/Discord notifications to get pinged the moment a matching role goes live.
- **Talent sourcing pipelines** — pair `webhookUrl` with your ATS or CRM to ingest new roles automatically.
- **Salary benchmarking** — collect structured compensation data by role, location, and employment type across the Austrian market.
- **Market research** — track which companies are hiring, where, and how listing volume shifts over time for a given keyword or region.

### How to scrape karriere.at jobs

1. **Set your search** — enter a Search Term, a Location (e.g. `"wien"`), or paste a karriere.at search URL into Start URLs.
2. **Choose filters** — set a Radius, toggle Remote Only, and set Max Results.
3. **Choose output shape** — toggle Include Full Details, pick a Description Format, and enable Compact Output if you're feeding an LLM.
4. **(Optional) track changes** — turn on Incremental Mode to only get new/changed jobs on repeat runs, and connect a notification channel to get alerted automatically.
5. **Run the actor** — click **Start** in the Apify Console, or trigger it via the [API](https://docs.apify.com/api/v2) or on a [schedule](https://docs.apify.com/platform/schedules).
6. **Get your data** — download the dataset as JSON/CSV/Excel, pull it via the API, or have it delivered straight to your notification channels.

### How much does it cost to scrape karriere.at?

This actor uses [Pay-Per-Event (PPE)](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) pricing — you're charged per job listing extracted, not per compute unit.

| Event | Price per event | Price per 1,000 |
|-------|----------------|-----------------|
| `job-scraped` (Free plan) | $0.00099 | **$0.99** |
| `job-scraped` (Bronze / Silver / Gold plans) | $0.00089 | **$0.89** |

A run collecting 500 jobs costs roughly $0.45–$0.50 depending on your Apify plan. All Apify accounts include a [free trial](https://apify.com/pricing) with credits to try the actor before committing to a paid plan.

### FAQ

**Why are some `salaryMin`/`salaryMax` fields `null`?**
Not every karriere.at listing discloses a salary range (Austrian law only requires a minimum for the specific collective-bargaining agreement to be shown). When compensation data isn't published, the salary fields are returned as `null`.

**What's the difference between `postedDate` and `postedDateRelative`?**
`postedDate` is an ISO 8601 timestamp available only when `includeDetails` is on. `postedDateRelative` is karriere.at's own relative label (e.g. `"vor 5 Tagen veröffentlicht"`) and is always available, even without full details.

**How does repost detection work?**
`skipReposts` fingerprints each job by its normalized title, company, and location. If a new job ID appears with the same fingerprint as one you've already seen (tracked via `stateKey`), it's treated as a repost and excluded.

**Can I run this on a schedule and only get new jobs?**
Yes — turn on `incrementalMode`, set a `stateKey` (or let it auto-derive from your search), and each run will tag jobs as `NEW`, `CHANGED`, `UNCHANGED`, `REAPPEARED`, or `EXPIRED` against the previous run.

**Does this actor support scheduling and integrations?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run it daily or weekly, connect it to [Zapier, Make, or Slack](https://apify.com/integrations), or call it through the [Apify API](https://docs.apify.com/api/v2) from your own backend.

**What are the limitations of this actor?**
⚠️

- `maxResults` is capped at 5000 per run
- Job-detail URLs (`/jobs/<id>/<slug>`) pasted into Start URLs aren't supported yet — use Search Term to find a job via search instead
- Results reflect karriere.at's public listings only

### Is it legal to scrape karriere.at?

Yes. This actor only accesses publicly available job listings that karriere.at and its customers have made visible for the purpose of recruitment. It does not bypass login walls, access private accounts, or collect personal data about individuals. Scraping publicly available data is generally considered legal — see [Apify's overview of web scraping legality](https://www.apify.com/is-web-scraping-legal) for more detail. Users are responsible for ensuring their use of the collected data complies with applicable laws and [karriere.at's Terms of Service](https://www.karriere.at/agb-bewerber).

### Python and JavaScript usage

**Python** ([apify-client](https://docs.apify.com/api/client/python/)):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "query": "software engineer",
    "location": "wien",
    "maxResults": 50,
    "includeDetails": True,
}

run = client.actor("parsebird/karriere-at-jobs-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"])
```

**JavaScript** ([apify-client](https://docs.apify.com/api/client/js/)):

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const input = {
    query: 'software engineer',
    location: 'wien',
    maxResults: 50,
    includeDetails: true,
};

const run = await client.actor('parsebird/karriere-at-jobs-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Related Actors

- [Arbeitnow Jobs Scraper](https://apify.com/parsebird/arbeitnow-jobs-scraper) — German and remote-friendly job listings
- [Xing Jobs Scraper](https://apify.com/parsebird/xing-jobs-scraper) — jobs from Xing, the DACH-region professional network
- [Arbeitsagentur Scraper](https://apify.com/parsebird/arbeitsagentur-scraper) — listings from Germany's federal job agency
- [Hiring.cafe Jobs Scraper](https://apify.com/parsebird/hiring-cafe-scraper) — 2.8M+ aggregated postings across 46 ATS platforms
- [Himalayas Remote Jobs Scraper](https://apify.com/parsebird/himalayas-remote-jobs-scraper) — worldwide remote-only job listings

Browse the full catalog on the [ParseBird Apify Store page](https://apify.com/parsebird).

# Actor input Schema

## `query` (type: `string`):

Single job search query (e.g. 'developer', 'marketing'). API aliases: searchQuery or keyword as a string, or keywords as a string/array. When keywords is an array, each entry runs as a separate search and results are merged/deduplicated.

## `startUrls` (type: `array`):

Optional alternative to Search Term(s) — paste karriere.at search URLs directly. Two shapes are supported: a query-string search (e.g. https://www.karriere.at/jobs?keywords=developer\&locations=wien\&radius=20\&homeoffice=1 — every parameter is parsed), or a location-only search (e.g. https://www.karriere.at/jobs/wien — single-segment path treated as location filter). URL params stack with explicit Search Term/Location/Radius inputs: explicit values win for location/radius, queries from URLs are merged + deduplicated with explicit queries, and Remote-only is OR-ed. Job-detail URLs (/jobs/<id>/<slug>) are not yet supported — use Search Term to find them via search.

## `location` (type: `string`):

City or region (e.g. 'wien', 'graz', 'salzburg').

## `radius` (type: `string`):

Search radius around location in kilometers.

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

Show only jobs with home office option.

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

Maximum total results (0 = unlimited).

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

Fetch full job details (description, structured salary, contact info, apply URL). API alias: fetchDetails.

## `descriptionMaxLength` (type: `integer`):

Truncate description to N chars. 0 = no truncation.

## `compact` (type: `boolean`):

Core fields only (for AI-agent/MCP workflows).

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

Pick a single description representation. all keeps every variant; text / html / markdown drop the others.

## `excludeEmptyFields` (type: `boolean`):

Drop null, empty-string, and empty-array fields from each record before push. Smaller payloads for AI agents and dashboards.

## `incrementalMode` (type: `boolean`):

Only emit new/changed jobs since last run.

## `stateKey` (type: `string`):

Optional stable identifier for the tracked search universe. Leave empty to auto-derive a stable identifier from your search inputs — different keyword/location/filter combinations get isolated state automatically.

## `skipReposts` (type: `boolean`):

Exclude listings detected as reposts of previously seen jobs.

## `emitUnchanged` (type: `boolean`):

When incremental mode is on, also emit listings whose content has not changed since the last run.

## `emitExpired` (type: `boolean`):

When incremental mode is on, also emit listings that were seen before but are no longer found.

## `telegramToken` (type: `string`):

Telegram bot token from @BotFather. Required for Telegram notifications.

## `telegramChatId` (type: `string`):

Telegram chat or channel ID where alerts are sent (e.g. "-100123456789" for a private group, or "@yourchannel").

## `discordWebhookUrl` (type: `string`):

Discord incoming webhook URL. Get one from Server Settings → Integrations → Webhooks.

## `slackWebhookUrl` (type: `string`):

Slack incoming webhook URL. Create at api.slack.com/messaging/webhooks.

## `whatsappPhoneNumberId` (type: `string`):

WhatsApp Business phone number ID from Meta Business Manager (NOT the phone number itself — the numeric ID shown next to your business number). Free service-conversation messages within 24 hours of last user-initiated contact.

## `whatsappAccessToken` (type: `string`):

Meta Cloud API access token with whatsapp\_business\_messaging scope. Get a permanent token from a system user in Meta Business Manager.

## `whatsappTo` (type: `string`):

Recipient phone in E.164 format (e.g. +4366412345678). Recipient must have messaged your business number within the last 24 hours — outside that window, free-form text is rejected by Meta.

## `webhookUrl` (type: `string`):

Generic webhook URL that receives a JSON POST with the full job payload + run metadata. Universal escape hatch for n8n / Make / Zapier / your own backend.

## `webhookHeaders` (type: `object`):

Optional headers (e.g. {"Authorization": "Bearer xyz"}) sent with the webhook POST.

## `notificationLimit` (type: `integer`):

Maximum number of jobs included in each notification message (1–20). Excess jobs are still in the dataset; notifications get a summary line.

## `notifyOnlyChanges` (type: `boolean`):

When Incremental Mode is on, only send notifications for NEW / UPDATED / REAPPEARED jobs. Has no effect outside incremental mode.

## `appConnector` (type: `string`):

Optional. Pick a connected app under Settings → API & Integrations to receive your results. Notion is supported today (a run-summary page); other MCP connectors are best-effort as Apify expands its catalog.

## `mcpIssueTeam` (type: `string`):

Only when the connected app is an issue tracker: the team (name or ID) the summary issue is created under, if that app requires one.

## Actor input object example

```json
{
  "query": "software engineer",
  "startUrls": [],
  "remoteOnly": false,
  "maxResults": 25,
  "includeDetails": true,
  "descriptionMaxLength": 0,
  "compact": false,
  "descriptionFormat": "all",
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "skipReposts": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "notificationLimit": 5,
  "notifyOnlyChanges": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "query": "software engineer",
    "startUrls": [],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/karriere-at-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 = {
    "query": "software engineer",
    "startUrls": [],
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/karriere-at-jobs-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 '{
  "query": "software engineer",
  "startUrls": [],
  "maxResults": 25
}' |
apify call parsebird/karriere-at-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/karriere-at-jobs-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/TozQ3NjOamZGKNAEE/builds/aquk8uSIjwLyk8VGZ/openapi.json