# karriere.at Jobs Scraper (`crawlerbros/karriere-at-jobs-scraper`) Actor

Scrape job listings from karriere.at, Austria's largest job board. Search by keyword, browse by Bundesland/city, job category, or company, and filter by contract type, job level, search radius, and home office. Optionally fetch each job's full description and structured salary.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## karriere.at Jobs Scraper

Scrape **karriere.at** — Austria's largest job board with 12,000+ active listings. Search by keyword (or leave it blank to browse the newest listings nationwide), browse by Bundesland (Austrian state) or city, browse by job category (Berufsfeld), browse by company, and filter by contract type (Vollzeit / Teilzeit / Lehre / etc.), job level, search radius, and home office availability. HTTP-only, no auth, no proxy required.

### What this actor does

- **Four modes:** `search` (free-text keyword, or blank to browse newest jobs nationwide), `browseLocation` (Bundesland / city), `browseCategory` (job field), `byCompany` (one or more specific employers)
- **Filters combine with any mode:** location, category, contract type, job level, search radius, company, home office only
- **Multi-select filters:** `location`, `category`, `contractType`, and `jobLevel` all accept multiple values combined with OR (e.g. Vollzeit OR Teilzeit)
- **`companySlug`:** browse one or more specific employers' open listings by slug (free text — see FAQ)
- **Search radius:** expand a single-city search to +10/20/30/50 km around it
- **Full national coverage:** all 9 Austrian Bundesländer plus 30 major cities via the `location` dropdown, plus any of Austria's thousands of additional town/district slugs via free-text `locationSlug`
- **20 job categories:** IT, Marketing, Finance, Sales, Engineering, Healthcare, and more
- **7 contract types:** Vollzeit, Teilzeit, Geringfügig, Praktika, Lehre, Diplomarbeit/Dissertation, Freelancer
- **Optional full job details:** enable `fetchJobDetails` to also pull each job's full HTML/text description, exact posted timestamp, the hiring company's own website, a structured salary breakdown (amount/currency/period), direct-apply availability, standardized employment-type code(s), the free-text seniority label, whether the hiring company is itself a staffing/recruitment agency, the job's category ID(s)/label(s), and the direct application URL — one extra request per job
- **Empty fields are omitted**

### Output per job

- `jobId` — karriere.at internal job ID
- `title` — job title
- `companyId`, `companyName`, `companySlug`, `companyUrl`, `companyLogoUrl`, `companyEmployees`, `companyMainLocation` — hiring company details (omitted for anonymous/Chiffre listings)
- `location` — comma-joined location names, `locations[]` — individual location names
- `contractType` — e.g. `Vollzeit`, `Teilzeit`, or `Vollzeit, Teilzeit` when a job offers multiple
- `salary` — advertised gross salary range/floor as shown on the listing (when disclosed)
- `isHomeOffice` — whether home office is offered
- `isPushedJob` — whether the listing is a promoted/sponsored posting
- `postedLabel` — original German posting-date label (e.g. `vor 3 Tagen veröffentlicht`)
- `postedDate` — posting date parsed to ISO `YYYY-MM-DD`
- `snippet` — short preview of the job description
- `sourceUrl` — canonical job listing URL
- `recordType: "job"`, `scrapedAt`

**With `fetchJobDetails: true` (one extra request per job):**

- `descriptionHtml` — full job description as HTML
- `descriptionText` — full job description as plain text
- `datePostedExact` — exact posting timestamp with timezone offset (vs. the day-resolution `postedDate` above)
- `companyWebsite` — the hiring company's own website (omitted for Chiffre listings)
- `salaryAmount`, `salaryCurrency`, `salaryPeriod` — structured salary breakdown (when disclosed as a single figure), e.g. `2900` / `EUR` / `Monthly`
- `salaryMin`, `salaryMax` — structured salary range instead of `salaryAmount` when the employer discloses a min/max band rather than one figure
- `isDirectApply` — whether the job supports karriere.at's one-click "smart apply" (vs. requiring an external application)
- `employmentTypeCodes` — standardized schema.org employment-type code(s), e.g. `["FULL_TIME"]` or `["FULL_TIME", "PART_TIME"]` — a machine-readable complement to the free-text German `contractType` label
- `jobLevel` — free-text German seniority label (e.g. `Berufserfahrung`, `Berufseinstieg`) — populated on every job regardless of whether the `jobLevel` input filter was used
- `companyIsEmploymentAgency` — whether the hiring company is itself a staffing/recruitment agency rather than the actual employer
- `categoryIds`, `categoryLabels` — the job's category/Berufsfeld ID(s) and German label(s) (the same IDs accepted by the `category` input filter) — one or more per job, populated on every job regardless of whether the `category` input filter was used
- `applyUrl` — the direct application target: karriere.at's own one-click "smart apply" link when `isDirectApply` is true, or the hiring company's own external application page/ATS link otherwise

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseLocation` / `browseCategory` / `byCompany` |
| `searchQuery` | string | `Softwareentwickler` | Free-text keyword (mode=search). Leave blank to browse the newest active listings nationwide. |
| `location` | array of strings | `[]` | One or more Bundesländer/cities (mode=browseLocation, or extra filter on any mode). OR semantics. |
| `locationSlug` | array of strings | `[]` | One or more additional karriere.at location slugs not in the `location` dropdown (any Austrian town/district — free text). OR-combines with `location`. |
| `category` | array of strings | `[]` | One or more job categories / Berufsfelder (mode=browseCategory, or extra filter on any mode). OR semantics. |
| `contractType` | array of strings | `[]` | One or more contract types (Vollzeit / Teilzeit / etc.) — applies to any mode. OR semantics. |
| `jobLevel` | array of strings | `[]` | One or more seniority levels — applies to any mode. OR semantics. |
| `companySlug` | array of strings | `[]` | One or more company slugs (mode=byCompany, or extra filter on any mode). Free text — up to 20 slugs; each runs as a separate lookup. |
| `radius` | string | – | Search radius in km (`0`/`10`/`20`/`30`/`50`). Only takes effect with exactly one city (not Bundesland) selected in `location`. |
| `homeofficeOnly` | boolean | `false` | Only jobs offering home office |
| `fetchJobDetails` | boolean | `false` | Also fetch each job's full description, exact posted timestamp, company website, structured salary, direct-apply flag, employment-type code(s), free-text seniority label, staffing-agency flag, and direct application URL. Adds one request per job — slower. |
| `maxItems` | integer | `50` | Maximum number of jobs to scrape (1–2000) |

### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "Softwareentwickler",
  "contractType": ["3960"],
  "maxItems": 50
}
```

### Example: browse a Bundesland with home office filter

```json
{
  "mode": "browseLocation",
  "location": ["wien"],
  "homeofficeOnly": true,
  "maxItems": 50
}
```

### Example: browse a job category with seniority filter

```json
{
  "mode": "browseCategory",
  "category": ["2172"],
  "jobLevel": ["3955"],
  "maxItems": 50
}
```

### Example: full-time OR part-time jobs within 20 km of Graz

```json
{
  "mode": "browseLocation",
  "location": ["graz"],
  "contractType": ["3960", "3961"],
  "radius": "20",
  "maxItems": 50
}
```

### Example: browse newest jobs nationwide across two Bundesländer

```json
{
  "mode": "search",
  "location": ["wien", "steiermark"],
  "maxItems": 50
}
```

### Example: full job details for a small batch

```json
{
  "mode": "search",
  "searchQuery": "Data Engineer",
  "fetchJobDetails": true,
  "maxItems": 20
}
```

### Example: browse a town not in the location dropdown

```json
{
  "mode": "browseLocation",
  "locationSlug": ["eferding"],
  "maxItems": 50
}
```

### Example: browse a company's open listings

```json
{
  "mode": "byCompany",
  "companySlug": ["epunkt-linz"],
  "maxItems": 50
}
```

### Use cases

- **Recruitment agencies** — monitor new job postings across Austria by category or region
- **Salary benchmarking** — collect advertised salary ranges by job field or location
- **Labor market research** — track hiring demand trends across Austrian Bundesländer
- **Remote-work analysis** — identify how many roles in a category or region offer home office
- **Competitive intelligence** — track a company's open positions and hiring pace
- **Job aggregators** — feed structured Austrian job listings into your own search product

### FAQ

**What is the data source?**
All data comes from the public `karriere.at/jobs` search — Austria's largest job board.

**Do I need an API key or login?**
No. The actor works without any credentials, cookies, or proxy configuration.

**Can I combine location, category, and contract type filters?**
Yes — all filters are additive and can be combined with any mode, e.g. `browseCategory` + `location` + `contractType` together. `location`, `category`, `contractType`, and `jobLevel` also accept multiple values each (OR semantics), e.g. `contractType: ["3960", "3961"]` returns Vollzeit **or** Teilzeit jobs.

**How do I browse a specific company's open jobs?**
Set `mode: "byCompany"` and `companySlug: ["<slug>"]`. The slug is the part after `/f/` in a karriere.at company page URL (e.g. `https://www.karriere.at/f/epunkt-linz` → `epunkt-linz`), or you can reuse the `companySlug` value from a previous run's output. You can list up to 20 slugs — karriere.at doesn't support combining multiple companies in a single OR query, so the actor runs one lookup per slug internally.

**Can I search without a keyword?**
Yes — leave `searchQuery` blank in `mode=search` to browse the newest active listings across all of Austria (or combine with `location`/`category`/etc. to browse a subset), sorted newest-first.

**What happens if `searchQuery` doesn't match anything (e.g. a made-up word)?**
karriere.at's own search returns a clean empty result (0 jobs) — this is upstream behavior (verified live), not something the actor can override. The run still succeeds; it just emits no records for that keyword rather than fabricating placeholder data. Leave `searchQuery` blank (rather than guessing a keyword) if you specifically want the newest nationwide listings.

**What happens if `searchQuery` is in a non-Latin script (e.g. Japanese, Chinese, Russian)?**
karriere.at's own backend silently strips non-Latin-script keywords server-side (verified live: the search form echoes an empty keyword back) and falls back to the newest nationwide listings — the same behavior as leaving `searchQuery` blank, rather than a clean 0-result response. This is genuine upstream input sanitization the actor cannot override; it only affects non-Latin scripts (Latin-script gibberish/unmatched words, including accented German/French/Spanish text, are matched or rejected normally and correctly return 0 results when nothing matches). If you need Austrian job listings for a non-Latin-script term, search the German/English equivalent instead.

**What does the `radius` filter do?**
It expands a search around a single specific city (e.g. `location: ["graz"]`) to include jobs within the chosen number of km. It only takes effect with exactly one **city-level** location selected — karriere.at ignores it for Bundesland-level or multi-location searches (verified against the live site).

**If I select a city and leave `radius` blank, do I only get jobs in that exact city?**
Not always — this is upstream behavior, verified live. For well-known/larger cities (e.g. `wien`, `graz`, `innsbruck`), leaving `radius` blank returns almost entirely exact matches for that city. But for some smaller towns (e.g. `traun`, `leonding`), karriere.at's own default search silently widens to a commuter-area radius around the nearest larger city when too few jobs are posted in the exact town that day — you may see `0` records tagged with that exact town even though the run succeeds with real, current jobs from the surrounding area. **If you need strictly exact-city matches, explicitly set `radius: "0"`** — this reliably restricts results to that exact location regardless of city size (verified live across multiple towns).

**The city/town I want isn't in the `location` dropdown — can I still search it?**
Yes. `location` only lists the 30 largest cities plus the 9 Bundesländer (a dropdown can't reasonably list Austria's thousands of towns/districts). Use `locationSlug` for any other town or district — it's free text and takes the same slug format you'd see in a job's location link (e.g. `https://www.karriere.at/jobs/eferding` → `eferding`). It combines with `location` via OR, and an unrecognized slug cleanly returns 0 jobs rather than erroring.

**Why is `companyId`/`companyName` missing on some listings?**
Some employers post anonymously ("Chiffre" listings). For these, all company-identifying fields are intentionally omitted rather than showing a placeholder.

**Why is `salary` missing on some listings?**
Not every employer discloses a salary range. The field is only included when karriere.at publishes one.

**Can I filter by minimum salary?**
No. karriere.at's salary filter requires a logged-in account on the site itself — it is not available on the public, unauthenticated search this actor uses. The `salary` field (and, with `fetchJobDetails: true`, the structured `salaryAmount`/`salaryCurrency`/`salaryPeriod` fields) is still returned on every listing where the employer discloses one, so you can filter the results yourself after scraping.

**What's the difference between `salary` and `salaryAmount`/`salaryCurrency`/`salaryPeriod`?**
`salary` is always present (when disclosed) and is the free-text label karriere.at shows on the listing, e.g. `"ab 2.900 € monatlich"`. `salaryAmount`/`salaryCurrency`/`salaryPeriod` are a machine-readable breakdown of the same figure (e.g. `2900`/`EUR`/`Monthly`) sourced from the job's structured data — only available with `fetchJobDetails: true`.

**Does the output tell me which category a job belongs to?**
With `fetchJobDetails: true`, yes — `categoryIds` and `categoryLabels` list the job's Berufsfeld ID(s)/label(s) (the same IDs the `category` input filter accepts), populated on every job regardless of whether you filtered by category. This is sourced from the job detail page only, so it's not available without `fetchJobDetails`.

**Can I sort results (e.g. by date or salary)?**
No. karriere.at's public search does not expose a sort parameter — results are returned in the site's default order (newest-first for unfiltered/keyword browsing). There is no reliable, unauthenticated sort axis to expose.

**How is `postedDate` calculated?**
karriere.at shows relative labels for recent posts (e.g. "Heute veröffentlicht", "vor 3 Tagen veröffentlicht") and an absolute date for older ones. The actor parses both into a consistent ISO `YYYY-MM-DD` date.

**Is this affiliated with karriere.at?**
No, this is an independent third-party actor built against karriere.at's public job search.

**How many jobs can I scrape in one run?**
Up to 2000 per run via `maxItems`. For larger volumes, run the actor multiple times with different filters (e.g. per Bundesland or per category).

### Limitations

- **Salary-range filtering is not available.** karriere.at gates its minimum-salary filter behind a logged-in account; it is not reachable from the public search this actor uses. The `salary` output field is still populated wherever the employer discloses a range.
- **No sort order control.** The public search API doesn't expose a sort/order parameter, so results follow karriere.at's own default ordering (newest-first for keyword/browse queries). There is no reliably-supportable sort axis to add.
- **`radius` only applies to single-city searches.** karriere.at's own UI disables the radius control for Bundesland-level and multi-location selections; the actor forwards the parameter anyway (it's harmless), but it has no effect outside a single-city selection — this mirrors the upstream site's own behavior exactly.
- **Leaving `radius` blank does not always mean "exact city only."** Verified live: for smaller Austrian towns, karriere.at's own default search silently expands to a commuter-area radius around the nearest larger city when the exact town has few current listings — you may get 0 records for that exact town while the run still succeeds with real regional jobs. Set `radius: "0"` explicitly for a guaranteed exact-city match.
- **`fetchJobDetails` is opt-in and slower.** It issues one extra request per job to fetch the full description/salary/date breakdown, roughly doubling run time. Leave it off (default) for fast bulk scraping; enable it when you need the full description text or a machine-readable salary. A job that went inactive between the search listing and the detail fetch is skipped for enrichment only — the base record (title, company, location, etc.) still ships.
- **`companySlug` runs one request sequence per slug.** karriere.at's `company=` filter only accepts a single slug per request — it silently ignores repeated params and comma-joined lists (verified live), unlike `location` which does support comma-join. The actor works around this by running one full paginated pass per slug (capped at 20 slugs per run) rather than exposing a broken multi-company OR query.
- **Non-Latin-script `searchQuery` values are silently stripped by karriere.at, not rejected.** Verified live: Japanese/Chinese/Cyrillic keywords are dropped server-side before matching and the search falls back to the newest nationwide listings (same as leaving `searchQuery` blank) rather than returning 0 results. This is upstream input handling the actor cannot override — Latin-script queries (including accented German/French/Spanish) are unaffected and match/reject normally.

# Actor input Schema

## `mode` (type: `string`):

What to fetch. `search` uses a free-text keyword (or leave blank to browse the newest listings nationwide), `browseLocation` browses by Bundesland/city, `browseCategory` browses by job field, `byCompany` browses all open listings from one or more specific employers.

## `searchQuery` (type: `string`):

Free-text keyword to search job titles and descriptions (mode=search). Leave blank to browse the newest active listings nationwide. E.g. `Softwareentwickler`, `Buchhaltung`, `Marketing`.

## `location` (type: `array`):

Browse or filter by one or more Austrian states (Bundesland) or major cities (mode=browseLocation, or as an extra filter on any mode). Multiple selections are combined with OR. Leave empty for all of Austria.

## `locationSlug` (type: `array`):

One or more additional karriere.at location slugs not covered by the `Location` dropdown above — Austria has thousands of town/district slugs beyond the 30 curated major cities. Free text; combines via OR with `location` (mode=browseLocation, or as an extra filter on any mode). Find a slug from a job's location link, e.g. `https://www.karriere.at/jobs/eferding` → `eferding`. An unrecognized slug cleanly returns 0 jobs rather than erroring.

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

Browse or filter by one or more job fields / profession categories (mode=browseCategory, or as an extra filter on any mode). Multiple selections are combined with OR. Leave empty for all categories.

## `contractType` (type: `array`):

Filter by one or more employment/contract types, e.g. Vollzeit (full-time) or Teilzeit (part-time). Multiple selections are combined with OR. Applies to any mode. Leave empty for any.

## `jobLevel` (type: `array`):

Filter by one or more seniority / position levels. Multiple selections are combined with OR. Applies to any mode. Leave empty for any.

## `companySlug` (type: `array`):

One or more karriere.at company slugs to browse all open listings from that employer (mode=byCompany, or as an extra filter on any mode). Copy the slug from a job's `companySlug` output field, or from a company page URL, e.g. `https://www.karriere.at/f/epunkt-linz` → `epunkt-linz`. Companies number in the tens of thousands, so this is free text rather than a dropdown. Each slug runs as a separate lookup (karriere.at does not support OR-combining companies in one request), so keep the list short for fast runs.

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

Only takes effect when exactly one city (not a Bundesland) is selected in `location` — expands the search to include jobs within N km of that city. Has no effect for Bundesland-level or multi-location selections (karriere.at ignores it in that case). Note: for some smaller towns, leaving this blank already defaults to a wider commuter-area match on karriere.at's side — set to `0` for a guaranteed exact-city-only match.

## `homeofficeOnly` (type: `boolean`):

Only return jobs that offer home office / remote work.

## `fetchJobDetails` (type: `boolean`):

Also fetch each job's detail page for a full HTML/text description, exact posted timestamp, the hiring company's own website, a structured salary breakdown (amount/currency/period), whether one-click "smart apply" is available, and standardized employment-type code(s). Adds one extra request per job, so runs take noticeably longer — recommended for smaller `maxItems` runs.

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

Maximum number of job listings to scrape.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Softwareentwickler",
  "location": [],
  "locationSlug": [],
  "category": [],
  "contractType": [],
  "jobLevel": [],
  "companySlug": [],
  "radius": "",
  "homeofficeOnly": false,
  "fetchJobDetails": false,
  "maxItems": 20
}
```

# Actor output Schema

## `jobs` (type: `string`):

Dataset containing all scraped karriere.at job listings.

# 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 = {
    "mode": "search",
    "searchQuery": "Softwareentwickler",
    "location": [],
    "locationSlug": [],
    "category": [],
    "contractType": [],
    "jobLevel": [],
    "companySlug": [],
    "radius": "",
    "homeofficeOnly": false,
    "fetchJobDetails": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "search",
    "searchQuery": "Softwareentwickler",
    "location": [],
    "locationSlug": [],
    "category": [],
    "contractType": [],
    "jobLevel": [],
    "companySlug": [],
    "radius": "",
    "homeofficeOnly": False,
    "fetchJobDetails": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "search",
  "searchQuery": "Softwareentwickler",
  "location": [],
  "locationSlug": [],
  "category": [],
  "contractType": [],
  "jobLevel": [],
  "companySlug": [],
  "radius": "",
  "homeofficeOnly": false,
  "fetchJobDetails": false,
  "maxItems": 20
}' |
apify call crawlerbros/karriere-at-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/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/FuC3x92DLvYBfkFrA/builds/nCICSjx3XDZaAvwAk/openapi.json