# Career Site Jobs Scraper (`daedal_quintuplet/career-site-jobs-scraper`) Actor

Scrape open jobs straight from company career sites on Lever, Ashby, SmartRecruiters, Workday and Workable: title, company, location, remote flag, salary, department, posted date, full description and apply link. Filters and only-new mode for daily feeds.

- **URL**: https://apify.com/daedal_quintuplet/career-site-jobs-scraper.md
- **Developed by:** [Big Man](https://apify.com/daedal_quintuplet) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Career Site Jobs Scraper

**Career Site Jobs Scraper** collects every open job straight from company career sites that run on **Lever, Ashby, SmartRecruiters, Workday and Workable**. Give it the careers URLs of the companies you care about and it returns one clean row per job: title, company, location, remote flag, workplace type, employment type, department, salary range (when the company publishes one), posted date, full description and the direct apply link.

People find this actor when they search for a **Lever jobs API**, **Ashby jobs scraper**, **Workday jobs scraper**, **SmartRecruiters API**, **Workable jobs export**, **career page scraper** or a **company job listings API**. It reads the same public job-board feeds that power each company's own careers page, so the data is first-hand: no job-board middlemen, no reposts, no expired ads.

- Five applicant tracking systems (ATS) in one actor, with one output format.
- Mix companies from different ATS in a single run.
- Filters for title, location, department, remote and posting date.
- "Only new jobs" mode for daily or hourly schedules.
- No login, no cookies, no browser: fast and cheap.

This actor is independent and is not affiliated with, endorsed by or connected to Lever, Ashby, SmartRecruiters, Workday or Workable. It only reads job postings that companies publish openly on their public career sites. Greenhouse boards are covered by our separate [Greenhouse Jobs Scraper](https://apify.com/daedal_quintuplet/greenhouse-jobs-scraper).

### What data you get

Every job is one dataset row with the same fields, whatever the source ATS. Field names follow the ones common job-posting APIs use (`title`, `organization`, `date_posted`, `url`, `description_text`, `source`), so you can switch over without changing your pipeline.

| Field | Type | Description |
| --- | --- | --- |
| `id` | text | The job's ID on its career site (Lever/Ashby UUID, SmartRecruiters posting ID, Workday job ID, Workable shortcode). |
| `title` | text | Job title as the company wrote it. |
| `organization` | text | Company name from the career site. On Workday this is the hiring legal entity, e.g. `Salesforce UK Limited`. |
| `organization_url` | text | The company's job board URL. |
| `url` | text | Public job page. |
| `apply_url` | text | Direct application link. |
| `date_posted` | timestamp | When the job was published (ISO 8601, UTC). |
| `location` | text | Primary location as written on the board. |
| `locations` | text\[] | All locations listed for the job. |
| `countries` | text\[] | Country names (ISO codes such as `GB` are converted to `United Kingdom`). |
| `remote_derived` | boolean | `true` when the board marks the job remote, or the location says remote. |
| `workplace_type` | text | `Remote`, `Hybrid`, `On Site` and similar, when the board publishes it. |
| `employment_type` | text\[] | `Full-time`, `Part-time`, `Contract`, `Internship` and so on. |
| `departments` | text\[] | Department and team names. |
| `salary` | object or null | `{min, max, currency, unit, text}` when the company publishes pay; `null` otherwise. |
| `description_text` | text | Full job description as plain text. |
| `description_html` | text | Full job description as HTML. |
| `source` | text | `lever`, `ashby`, `smartrecruiters`, `workday` or `workable`. |
| `source_type` | text | Always `ats`. |
| `source_domain` | text | Domain of the career site, e.g. `jobs.lever.co` or `nvidia.wd5.myworkdayjobs.com`. |
| `company_slug` | text | The company's board name on that ATS, e.g. `palantir` or `nvidia/NVIDIAExternalCareerSite`. |
| `scrapedAt` | timestamp | When the row was collected. |

What each ATS publishes differs a little. In our test runs (over 2,000 jobs) the core fields (title, company, URLs, date, location, country, employment type, description) were filled on every row. Salary appears when the employer publishes it, which is common on Ashby and Lever boards for US roles. Workday boards don't publish departments, workplace type or pay in their public feed, so those fields are empty for Workday jobs.

### How to use it

1. Open the company's careers page and copy its job board URL. You can recognise the ATS from the address:
   - Lever: `https://jobs.lever.co/<company>`
   - Ashby: `https://jobs.ashbyhq.com/<company>`
   - SmartRecruiters: `https://careers.smartrecruiters.com/<company>` or `https://jobs.smartrecruiters.com/<company>`
   - Workday: `https://<company>.wd5.myworkdayjobs.com/<site>` (the `wd` number varies)
   - Workable: `https://apply.workable.com/<company>`
2. Paste one or more URLs into **Career sites**. You can also write `lever:spotify`, `ashby:notion`, `smartrecruiters:BoschGroup` or `workable:huggingface`, or just a bare name like `spotify` and the actor looks it up on Lever, Ashby, SmartRecruiters and Workable.
3. Optionally narrow the jobs with **Title contains**, **Title excludes**, **Location contains**, **Department contains**, **Remote jobs only** or **Posted within (days)**.
4. Set **Max jobs** (total) and, if you like, **Max jobs per company**.
5. Click **Start**. Results appear in the **Output** tab as a table and can be downloaded as JSON, CSV, Excel, XML or HTML, or read through the API.

### Input examples

**Several companies on different ATS, software roles only** (the `Soft:*` prefix style used by other job APIs works too):

```json
{
  "companies": [
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/ramp",
    "https://apply.workable.com/huggingface"
  ],
  "titleSearch": ["Soft:*"]
}
```

**London jobs from three companies**, using the full "City, Region, Country" location form (it also matches boards that just write "London"):

```json
{
  "companies": ["lever:palantir", "ashby:notion", "https://careers.smartrecruiters.com/BoschGroup"],
  "locationSearch": ["London, England, United Kingdom"],
  "maxItemsPerCompany": 40
}
```

**A large Workday career site, only jobs posted in the last 7 days:**

```json
{
  "companies": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],
  "postedWithinDays": 7,
  "maxItems": 200
}
```

**Remote jobs only, without descriptions (fastest and smallest output):**

```json
{
  "companies": ["https://jobs.lever.co/palantir", "https://jobs.ashbyhq.com/ramp", "https://apply.workable.com/huggingface"],
  "remoteOnly": true,
  "includeDescription": false
}
```

**Engineering department only, for a daily feed that returns just new jobs:**

```json
{
  "companies": ["https://jobs.lever.co/spotify", "https://jobs.ashbyhq.com/notion"],
  "departmentSearch": ["engineering"],
  "onlyNew": true
}
```

### Output example

Real rows from a test run (descriptions shortened here):

```json
[
  {
    "id": "34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "title": "Security Engineer, Cloud",
    "organization": "Ramp",
    "organization_url": "https://jobs.ashbyhq.com/ramp",
    "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "apply_url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
    "date_posted": "2026-04-07T17:12:35.753Z",
    "location": "New York, NY (HQ)",
    "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
    "countries": ["United States"],
    "remote_derived": false,
    "workplace_type": "Hybrid",
    "employment_type": ["Full-time"],
    "departments": ["Engineering", "Backend"],
    "salary": { "min": 211400, "max": 290600, "currency": "USD", "unit": "YEAR", "text": "$211.4K – $290.6K • Offers Equity" },
    "description_text": "ABOUT RAMP\n\nRamp is building the smart infrastructure for finance teams...",
    "description_html": "<h1><strong>About Ramp</strong></h1>...",
    "source": "ashby",
    "source_type": "ats",
    "source_domain": "jobs.ashbyhq.com",
    "company_slug": "ramp",
    "scrapedAt": "2026-11-09T23:09:01.000Z"
  },
  {
    "id": "f480ab0507ff101501f6e1217d790000",
    "title": "Senior Network Solution Engineer (Weekend Coverage)",
    "organization": "NVIDIA USA",
    "organization_url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Network-Solution-Engineer--Weekend-Coverage-_JR2020101",
    "apply_url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Network-Solution-Engineer--Weekend-Coverage-_JR2020101/apply",
    "date_posted": "2026-11-05T00:00:00.000Z",
    "location": "US, CA, Santa Clara",
    "locations": ["US, CA, Santa Clara", "US, MA, Westford", "US, TX, Austin", "US, NC, Durham", "US, WA, Redmond", "US, NY, New York"],
    "countries": ["United States"],
    "remote_derived": false,
    "workplace_type": null,
    "employment_type": ["Full-time"],
    "departments": [],
    "salary": null,
    "description_text": "The NVIDIA Experience (NVEX) Solutions Engineering team is looking for a senior Computer or Software Engineer...",
    "source": "workday",
    "source_type": "ats",
    "source_domain": "nvidia.wd5.myworkdayjobs.com",
    "company_slug": "nvidia/NVIDIAExternalCareerSite"
  },
  {
    "id": "ab7e3425-81d5-4705-a7b5-cd60c8a45cdb",
    "title": "Backend Software Engineer - Application Development",
    "organization": "Palantir Technologies",
    "url": "https://jobs.lever.co/palantir/ab7e3425-81d5-4705-a7b5-cd60c8a45cdb",
    "apply_url": "https://jobs.lever.co/palantir/ab7e3425-81d5-4705-a7b5-cd60c8a45cdb/apply",
    "date_posted": "2024-03-11T21:04:42.166Z",
    "location": "New York, NY",
    "countries": ["United States"],
    "remote_derived": false,
    "workplace_type": "Hybrid",
    "employment_type": ["Full-time"],
    "departments": ["Dev"],
    "source": "lever"
  }
]
```

### Use cases

- **Job boards and niche job sites:** fill your board with first-hand postings from the companies in your niche, with real apply links and fresh dates.
- **Recruiting and sourcing:** watch target companies for new openings in the roles you place, and react the day they are posted.
- **Sales intelligence:** hiring is a buying signal. A company opening five data-engineering roles is likely buying data tools; feed new postings into your CRM.
- **Market and salary research:** compare published pay ranges by role, seniority and city across companies.
- **Competitor tracking:** see which teams your competitors are growing, where they are opening offices and which skills they need.
- **Job seekers and career tools:** build alerts for remote roles or specific titles across a list of dream companies.
- **AI and data projects:** collect clean job descriptions for skills extraction, classification or embeddings.

### Run it on a schedule and get only new jobs

1. Save your input as a **task** in Apify Console (the **Save as a new task** button).
2. Turn on **Only new jobs** (`"onlyNew": true`). The actor remembers the IDs of jobs it has already returned, for 180 days, in a key-value store named `career-site-jobs-seen` in your account. Later runs skip them, so each run returns only jobs posted (or reopened) since the last one.
3. Open **Schedules**, create a schedule (for example daily at 07:00 or every 6 hours) and attach the task.
4. Add an integration (webhook, Slack, Google Sheets, email via Zapier or Make) to receive the new jobs automatically.

To start over and get every job again, run once with **Only new jobs** off, or delete the `career-site-jobs-seen` store.

### Integrations

**API (one call, returns the jobs):**

```
POST https://api.apify.com/v2/acts/daedal_quintuplet~career-site-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN
Content-Type: application/json

{"companies": ["https://jobs.lever.co/spotify", "ashby:notion"], "titleSearch": ["engineer"]}
```

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

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("daedal_quintuplet/career-site-jobs-scraper").call(
    run_input={"companies": ["https://jobs.lever.co/spotify", "ashby:notion"], "titleSearch": ["engineer"]}
)
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    if job.get("error"):
        continue
    print(job["source"], "|", job["organization"], "|", job["title"], "|", job["location"], "|", job["url"])
```

**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('daedal_quintuplet/career-site-jobs-scraper').call({
    companies: ['https://jobs.lever.co/spotify', 'ashby:notion'],
    titleSearch: ['engineer'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.filter((job) => !job.error).forEach((job) => console.log(job.organization, '|', job.title, '|', job.url));
```

**No-code tools:**

- **n8n:** use the Apify node, choose *Run actor*, enter `daedal_quintuplet/career-site-jobs-scraper` and your input JSON, then read the dataset items.
- **Make:** use the Apify app's *Run an Actor* module, then *Get Dataset Items*.
- **Zapier:** use the Apify integration's *Run Actor* action, or trigger a Zap when a scheduled run finishes.
- **Google Sheets, Slack, webhooks:** connect them from the actor's **Integrations** tab in Apify Console.

**AI agents (MCP):** the actor is available through Apify's MCP server (`https://mcp.apify.com`). Add `daedal_quintuplet/career-site-jobs-scraper` as a tool and Claude, Cursor or any MCP client can pull jobs on request. Every input field has a plain description and an example so the agent can fill it in.

### Pricing

Pay per result: **$1.50 per 1,000 jobs** ($0.0015 per job). Error rows are free. A company with 300 open jobs costs $0.45. Platform usage is included in the price.

### Limits and error items

- **Supported career sites:** Lever, Ashby, SmartRecruiters, Workday and Workable public job boards. Other career sites (iCIMS, Taleo, SuccessFactors, custom pages) are not supported; Greenhouse has its own actor.
- **Speed:** Lever and Ashby return a whole board in one request, so hundreds of jobs take seconds. SmartRecruiters, Workday and Workable need one extra request per job for the description; a 2,000-job Workday site with a location filter takes about 3 minutes. Turn off **Include full description** for faster SmartRecruiters and Workable runs.
- **Workday title filters** are passed to Workday's own keyword search (one search per term) and then checked again on the title, so big Workday sites stay fast. **Department filters** drop Workday jobs, because Workday boards don't publish departments.
- **Location matching** is a case-insensitive "contains" match on the job's locations and countries. A "City, Region, Country" term also matches the city alone.
- **Error items:** instead of failing the run, the actor adds a row with `"error": true` and a `message` when an input isn't a supported career site, a board isn't found, a board has no open jobs, or no job matches your filters. Error rows are never charged. Filter them out with `error != true`.
- **Restarts:** if Apify moves the run to another server mid-run, it resumes where it stopped without repeating jobs or charges.
- Only jobs the company publishes publicly are returned; internal-only postings are not visible.

### FAQ

**Which companies can I scrape?**
Any company whose careers page is hosted on Lever, Ashby, SmartRecruiters, Workday or Workable. Thousands of companies use these systems, from startups (Ashby, Lever, Workable) to large enterprises (Workday, SmartRecruiters).

**How do I find a company's job board URL?**
Open the company's careers page and click any job. The address bar shows the ATS domain (`jobs.lever.co`, `jobs.ashbyhq.com`, `myworkdayjobs.com`, `smartrecruiters.com`, `apply.workable.com`). Paste the board part of that URL.

**Is this a database of all jobs?**
No. It reads live data from the career sites you list, at the moment you run it. You choose the companies; the data is always current.

**Why is salary empty for some jobs?**
The actor returns pay only when the employer publishes it. Many US postings include a range (often required by state pay-transparency laws); many others don't.

**Does it return the full description?**
Yes, as plain text (`description_text`) and HTML (`description_html`). Turn off **Include full description** if you only need titles and links.

**Can I mix companies from different ATS in one run?**
Yes. Every row has the same fields, and `source` tells you where it came from.

**How fresh is the data?**
Live: each run reads the career sites directly, so a job posted a minute ago is included and closed jobs disappear.

**Is it legal to scrape job postings?**
The actor only reads job postings that companies publish openly for anyone to see, without logging in. Job listings are business information, not personal data. Check the rules that apply to your use case and jurisdiction.

### Related actors

- [Greenhouse Jobs Scraper](https://apify.com/daedal_quintuplet/greenhouse-jobs-scraper): every open job from Greenhouse job boards, with salary ranges.
- [Google Jobs Scraper (US & UK)](https://apify.com/daedal_quintuplet/google-jobs-scraper): job listings from Google's job search, with apply links from many sites.
- [Seek AU Job Scraper](https://apify.com/daedal_quintuplet/seek-au-job-scraper): job listings from Seek Australia.
- [Seek NZ Job Scraper](https://apify.com/daedal_quintuplet/seek-nz-job-scraper): job listings from Seek New Zealand.
- [Google Trends Scraper (timeseries + regions + related)](https://apify.com/daedal_quintuplet/google-trends-scraper-all-widgets): interest over time, by region, and related topics and queries.
- [Google Images Scraper](https://apify.com/daedal_quintuplet/google-images-scraper): image results with source pages and sizes.

# Actor input Schema

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

Company job boards to scrape, one per line: the careers URL (https://jobs.lever.co/spotify, https://jobs.ashbyhq.com/notion, https://careers.smartrecruiters.com/BoschGroup, https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite, https://apply.workable.com/huggingface) or 'ats:name' (lever:spotify, ashby:notion, smartrecruiters:BoschGroup, workable:huggingface). A bare name like 'spotify' is looked up on Lever, Ashby, SmartRecruiters and Workable. Example: \["https://jobs.lever.co/spotify", "ashby:notion"].

## `titleSearch` (type: `array`):

Keep only jobs whose title contains any of these words (case-insensitive; 'Soft:\*' prefix style also works). Leave empty for all jobs. Example: \["engineer", "data"].

## `titleExclusionSearch` (type: `array`):

Drop jobs whose title contains any of these words (case-insensitive). Example: \["intern", "senior"].

## `locationSearch` (type: `array`):

Keep only jobs whose location contains any of these words (case-insensitive). 'City, Region, Country' terms also match on the city alone. Example: \["London", "United States", "remote"].

## `departmentSearch` (type: `array`):

Keep only jobs whose department or team contains any of these words (case-insensitive). Workday boards don't publish departments, so this filter drops all Workday jobs. Example: \["engineering", "sales"].

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

Keep only jobs marked remote by the career site (or with 'remote' in the location). Example: false.

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

Keep only jobs posted in the last N days. Leave empty for any date. Example: 7.

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

Return the full job description as text and HTML. SmartRecruiters, Workday and Workable need one extra request per job for it; turn off for faster, smaller runs. Example: true.

## `maxItemsPerCompany` (type: `integer`):

Stop after this many jobs from any one career site. Leave empty for no per-company limit. Example: 100.

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

Stop after this many jobs in total across all career sites. Example: 500.

## `onlyNew` (type: `boolean`):

For scheduled runs: skip jobs already returned by earlier runs (remembered for 180 days in the 'career-site-jobs-seen' key-value store of your account). Example: false.

## Actor input object example

```json
{
  "companies": [
    "https://jobs.lever.co/spotify",
    "ashby:notion",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "titleSearch": [
    "engineer",
    "data"
  ],
  "titleExclusionSearch": [
    "intern"
  ],
  "locationSearch": [
    "London",
    "remote"
  ],
  "departmentSearch": [
    "engineering"
  ],
  "remoteOnly": false,
  "postedWithinDays": 7,
  "includeDescription": true,
  "maxItemsPerCompany": 100,
  "maxItems": 500,
  "onlyNew": false
}
```

# Actor output Schema

## `jobs` (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 = {
    "companies": [
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/notion"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("daedal_quintuplet/career-site-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 = { "companies": [
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/notion",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("daedal_quintuplet/career-site-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 '{
  "companies": [
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/notion"
  ]
}' |
apify call daedal_quintuplet/career-site-jobs-scraper --silent --output-dataset

```

## MCP server setup

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