# Remote Job Listings Scraper (`axiomworks/remote-jobs-scraper`) Actor

Scrape public remote job feeds from Remotive, Himalayas, Arbeitnow and Jobicy. Get normalized job titles, companies, apply links, posting dates, locations, salary details, tags and descriptions. Choose sources, filter results and set a total item limit; jobs are selected round-robin across sources.

- **URL**: https://apify.com/axiomworks/remote-jobs-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 results

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

**Returns:** one row per remote job with `id`, `source`, `title`, `company`, `applyUrl`, `postedAt` and `location`.
**Input:** `{"sources": ["remotive", "himalayas", "jobicy", "arbeitnow"], "maxItems": 40}`
**Best for:** remote job boards and newsletters, salary and hiring-trend research, lead lists of companies that hire remotely.

```json
{
    "id": "himalayas:companies/baker-tilly/jobs/sr-manager-technology-enablement-consulting-managed-services",
    "source": "himalayas",
    "title": "Sr Manager, Technology Enablement (Consulting & Managed Services)",
    "company": "Baker Tilly",
    "applyUrl": "https://himalayas.app/companies/baker-tilly/jobs/sr-manager-technology-enablement-consulting-managed-services",
    "postedAt": "2026-10-14T08:16:45.000Z",
    "location": "United States"
}
```

### What does Remote Jobs Scraper do?

Remote Jobs Scraper is a remote jobs API in one Actor. It reads four open remote job boards (Remotive, Himalayas, Arbeitnow and Jobicy) and returns every listing in the same format.

All four sources are public JSON feeds that load without logging in. The Actor reads them politely, with about one request per second per host, so a normal run is a handful of requests and finishes in well under a minute. Requests to independent boards run concurrently, while pages from each board remain sequential. Results retain the selected sources’ round-robin order; a source contributes when it has matching jobs and the item limit leaves room. With `maxItems: 1`, only the first selected source is requested unless it returns no usable jobs.

### What data can you get from the remote job boards?

Every record has the same fields, whichever board it came from. Fields a board does not publish are returned as `null`. The `id` is prefixed with the source name, so ids never collide across boards.

| Field | Description | Example |
|---|---|---|
| `id` | Source-prefixed job ID, unique within a run | `remotive:2091132` |
| `source` | Board the job came from: `remotive`, `himalayas`, `arbeitnow`, `jobicy` or `remoteok` | `remotive` |
| `title` | Job title | `Senior back-end Engineer` |
| `company` | Hiring company | `Lemon.io` |
| `applyUrl` | Original job link on the source board, unmodified | `https://remotive.com/remote-jobs/...` |
| `postedAt` | Publication date, ISO 8601 in UTC | `2026-09-30T13:15:26.000Z` |
| `category` | Category or industry of the job | `Software Development` |
| `jobType` | Employment type in lower snake case | `full_time` |
| `location` | Location or region the candidate must be in, `Worldwide` when unrestricted | `USA` |
| `locationRestrictions` | List of countries or regions | `["USA", "Canada"]` |
| `salaryMin` | Lower end of the salary range | `107000` |
| `salaryMax` | Upper end of the salary range | `219000` |
| `salaryCurrency` | Currency code | `USD` |
| `salaryPeriod` | `yearly`, `monthly`, `weekly` or `hourly` | `yearly` |
| `salaryText` | Raw salary text, where the board only gives free text | `80,000 - 120,000 USD` |
| `seniority` | Seniority level when the board lists one | `Senior` |
| `tags` | Skill tags or categories | `["python", "aws"]` |
| `companyLogo` | Company logo URL | `https://remotive.com/job/2091132/logo` |
| `description` | Job description as plain text | `Senior Developer? Work Remote.` |
| `descriptionHtml` | Job description as the original HTML | `<p>Senior Developer?</p>` |
| `sourceUrl` | Job page on the source board | `https://remotive.com/remote-jobs/...` |

Salary data is sparse on these boards. Himalayas and Jobicy publish structured salary ranges for some listings, Remotive publishes free text that the Actor parses when it can, and Arbeitnow publishes none. Expect salary fields on a minority of rows, and use the other fields for filtering.

### How to use Remote Jobs Scraper

1. Open the Actor in Apify Console and go to the Input tab.
2. Pick the sources you want, or leave all four selected.
3. Optionally add a search keyword, a category or a location restriction.
4. Set the maximum number of results.
5. Click Start. When the run finishes, open the Output tab and export the dataset as JSON, CSV, Excel, XML or HTML.

Tips:

`maxItems` is the total across all sources. Results are taken round-robin, so selected boards contribute when they have matching jobs and the limit leaves room. Filters are applied to the normalised fields, so the same keyword works on every source.

- `includeDescription: false` returns null `description` and `descriptionHtml` while keeping titles, companies and links.
- Schedule the Actor hourly or daily and compare the `id` values between runs to find new listings.

### Input

Three optional filters help narrow an export before any matching row is saved. `salaryOnly: true` retains jobs with a published numeric salary bound or nonempty raw salary text. It does not infer compensation, convert currencies or guarantee that the published range applies to every location. `postedWithinDays` accepts 0 to disable the age filter, or 1–3650 to keep only postings within that many days. Enabled age filtering excludes missing and future dates. A posting date is a feed value, not proof that the vacancy is still open.

`excludeKeywords` accepts an array of phrases. A match in the title, company, category, tags or full available description excludes the job, ignoring case. For example, `["unpaid", "commission only"]` removes listings containing either phrase. Exclusions inspect all available description text even with `includeDescription: false`. These filters combine with the existing search, category and location filters using AND. Defaults preserve the existing unfiltered behavior. Filtering takes place before saving and charging a result; rejected jobs do not consume the shared item limit. Narrow filters can exhaust a source or reach its scan limit before filling `maxItems`.

`jobTypes` selects one or more normalized employment types: `full_time`, `part_time`, `contract`, `freelance`, `internship` or `working_student`. An empty array keeps every type. A selected list excludes jobs whose type is missing, including RemoteOK rows, rather than guessing from their description. Matching uses the existing `jobType` field exactly; a listing need match only one selected type. For example, `{"sources":["himalayas","jobicy"],"jobTypes":["full_time"],"maxItems":7}` collects full-time matches from those boards.

`companyKeywords` keeps company names containing any supplied phrase, ignoring case. It examines only `company`, so another employer mentioned in a description cannot qualify a job. Empty arrays disable both new filters. Active filters combine using AND, apply before saving and charging, and can return fewer rows than requested. They do not infer missing employment details or contact company websites.

A salary-focused input is `{"sources":["himalayas","jobicy"],"salaryOnly":true,"postedWithinDays":30,"excludeKeywords":["unpaid"],"maxItems":20}`. These filters use source data without third-party enrichment.

| Field | Type | Required | Description |
|---|---|---|---|
| `sources` | array of strings | No | Boards to read: `remotive`, `himalayas`, `arbeitnow`, `jobicy`, `remoteok`. Default: the first four. Add `remoteok` to include RemoteOK. |
| `searchQuery` | string | No | Optional keywords, e.g. `python developer`. Source search rules apply on Remotive, Himalayas and Jobicy; Arbeitnow and RemoteOK require every word in title, company, tags, category or description text. |
| `category` | string | No | Keep jobs whose category, title or tags contain this text, case-insensitive; hyphens and underscores match spaces. |
| `locationFilter` | string | No | Keep jobs whose location or restrictions contain this text, for example `USA`, `Europe` or `Worldwide`. |
| `includeDescription` | boolean | No | Include `description` and `descriptionHtml`. Default `true`. |
| `jobTypes` | array of enum strings | No | Keep any selected normalized employment type; default `[]` accepts all. Missing types are excluded when active. |
| `companyKeywords` | array of strings | No | Keep any matching company name phrase, ignoring case; default `[]`. |
| `salaryOnly` | boolean | No | Require source salary data, e.g. `true`; default `false`. |
| `postedWithinDays` | integer | No | Maximum posting age, e.g. `7` for the past week; 0–3650, default `0` disables filtering. |
| `excludeKeywords` | array of strings | No | Exclude any phrase in available job text, e.g. `["unpaid"]`; default `[]`. |
| `maxItems` | integer | No | Total number of jobs, 1-10000, default 50. |
| `dedupe` | boolean | No | Collapse jobs with the same company, title and apply-link host. Default `true`. |
| `proxyConfiguration` | object | No | Proxy settings. Default: no proxy, because the sources are open JSON APIs. |

```json
{
    "sources": ["himalayas", "jobicy"],
    "searchQuery": "engineer",
    "category": "",
    "locationFilter": "USA",
    "includeDescription": true,
    "maxItems": 30,
    "dedupe": true,
    "proxyConfiguration": { "useApifyProxy": false }
}
```

How filtering works: Remotive uses server-side search, Himalayas uses its search API, and Jobicy uses tag search. Those sources keep their own keyword matching rules. Arbeitnow and RemoteOK use client-side matching: every search word must occur in the title, company, tags, category or first 3000 description characters. Category and location filters apply to every source and combine with keyword search using AND. Category checks category, title and tags; location checks location restriction text. `Europe` does not automatically match every European country, and `USA` does not match every spelling of United States. Turning off descriptions changes output only, not matching. Narrow filters mean the Actor reads more pages before it finds enough matches, and it stops after a bounded number of pages, so a very narrow filter can return fewer jobs than `maxItems`.

### Output

Each job is one dataset row. Here are real rows from a run (descriptions shortened here, full text in the dataset):

```json
[
    {
        "id": "remotive:2091132",
        "source": "remotive",
        "title": "Senior back-end Engineer",
        "company": "Lemon.io",
        "applyUrl": "https://remotive.com/remote-jobs/software-development/senior-back-end-engineer-2091132",
        "postedAt": "2026-09-30T13:15:26.000Z",
        "category": "Software Development",
        "jobType": "full_time",
        "location": "Europe, USA, UK, Canada, Australia, Ireland, Switzerland, Singapore, Mexico, Iceland, Norway",
        "salaryMin": null,
        "salaryMax": null,
        "companyLogo": "https://remotive.com/job/2091132/logo"
    },
    {
        "id": "himalayas:companies/capslock/jobs/senior-performance-copywriter-1931759832",
        "source": "himalayas",
        "title": "Senior Performance Copywriter",
        "company": "CapsLock",
        "applyUrl": "https://himalayas.app/companies/capslock/jobs/senior-performance-copywriter-1931759832",
        "postedAt": "2026-10-03T16:41:12.000Z",
        "jobType": "full_time",
        "location": "Belgium",
        "seniority": "Senior"
    }
]
```

You can download the dataset as JSON, CSV, Excel, XML, RSS or HTML, or read it through the Apify API.

### How much does it cost to scrape remote jobs?

Remote Jobs Scraper is charged per result. You pay only for the jobs returned, and `maxItems` caps how many that can be, so a run never costs more than you plan for. See the Pricing tab of the Actor for the current price. Because the sources are free public APIs, there is no proxy cost by default.

### Use with AI agents (MCP)

Connect Remote Jobs Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

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

Example prompts:

1. "Find 30 remote software engineering jobs from Himalayas and Jobicy and list company, title and apply link."
2. "Which remote jobs posted today mention Python and accept candidates from Europe?"
3. "Get 50 remote marketing jobs with a listed salary range and summarise the typical pay."

Use only the documented input fields. For recent postings, set `postedWithinDays: 1` for the past day or `7` for the past week; this is a rolling age window, not a calendar-day filter. For published compensation, set `salaryOnly: true`, then inspect salary units and currencies before comparing jobs. Use `excludeKeywords: ["unpaid"]` to remove matching phrases. `maxItems` is one shared budget across sources. A zero-row run is successful, not proof that no remote jobs exist: clear `searchQuery`, `category`, `locationFilter` , `excludeKeywords`, `jobTypes` and `companyKeywords`, set `salaryOnly: false` and `postedWithinDays: 0`, then try `{"sources":["himalayas","jobicy"],"maxItems":7}`. Source failures appear in the log; retry later or choose another source. A blocked source can use the optional proxy settings on Apify. The default prefill requests 40 jobs from four sources without filters.

### Integrations and API

Run Remote Jobs Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token and send it in the `Authorization` header, never in the URL.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/remote-jobs-scraper").call(
    run_input={"sources": ["himalayas", "jobicy"], "searchQuery": "engineer", "maxItems": 30}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"], item["applyUrl"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/remote-jobs-scraper').call({
    sources: ['himalayas', 'jobicy'],
    searchQuery: 'engineer',
    maxItems: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~remote-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sources": ["himalayas", "jobicy"], "searchQuery": "engineer", "maxItems": 30}'
```

You can also connect the dataset to Make, Zapier, n8n, Google Sheets or a webhook from the Integrations tab, and schedule runs to keep a job board or spreadsheet fresh.

### FAQ

**Which sites does it cover?**
Remotive, Himalayas, Arbeitnow and Jobicy by default, plus RemoteOK when you add `remoteok` to `sources`. Pick any subset with the `sources` input. RemoteOK makes one request per run, and its salary range (USD per year) is filled only where the listing publishes one. Please link back to RemoteOK and name it as the source when you republish its jobs.

**How fresh is the data?**
Himalayas, Arbeitnow and Jobicy update continuously, Arbeitnow roughly hourly. Remotive delays its public feed by about 24 hours, and asks API users to fetch only a few times a day, so the Actor makes exactly one Remotive request per run.

**Why did I get fewer jobs than `maxItems`?**
Either the filters matched fewer jobs than requested, or a board has fewer matching listings. Remotive's public feed holds only a small set of jobs at a time. Arbeitnow is mostly on-site German jobs, and only listings flagged remote are kept. Add sources or loosen filters to get more. A source error is logged and other sources continue. If every source fails or no jobs match, the run succeeds with zero rows and a status message explaining what to try.

**Why are salary fields empty?**
Most listings on these boards do not publish a salary. The fields are filled only when the source provides a range, or when Remotive's free-text salary can be parsed.

**Are duplicates removed?**
By default, yes. Jobs with the same company, title and apply-link host collapse into one. Set `dedupe` to `false` to keep everything.

**Do I need a proxy?**
No. The four sources are open JSON APIs and the Actor runs without a proxy by default. If requests are blocked, the Actor retries with backoff, and you can enable Apify Proxy in the input.

**Can I get the original posting?**
Yes. `applyUrl` is the unmodified link on the source board, and the `source` field names the board. Please keep the attribution and link back when you republish listings.

### Is it legal to scrape remote job boards?

The Actor reads only public job listing data from open APIs that need no login and no CAPTCHA solving. Job listings describe positions, not private individuals, but you remain responsible for how you use the data, including compliance with privacy rules such as GDPR and with each board's terms. Several boards ask for attribution and a link back to the original listing; Remotive, for example, asks that you link to its job URL, mention it as the source, and not republish its jobs on other job aggregators. Keep `source` and `applyUrl` intact when you display or share results. This is not legal advice, and this Actor is not affiliated with or endorsed by Remotive, Himalayas, Arbeitnow or Jobicy.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `sources` (type: `array`):

Job boards as an array, e.g. \["himalayas", "jobicy"]. Allowed: remotive, himalayas, arbeitnow, jobicy, remoteok. Default: the first four. RemoteOK is opt-in. Results rotate through selected sources with available matches; maxItems is shared. With maxItems: 1, only the first source is fetched unless it yields no jobs.

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

Job keywords, e.g. "python developer"; empty means no keyword filter. Remotive, Himalayas and Jobicy use their own search matching. Arbeitnow and RemoteOK require every word in title, company, tags, category or the first 3000 description characters. Combined with category and locationFilter; text is trimmed to 200 characters.

## `category` (type: `string`):

Category text, e.g. "software" or "marketing"; empty means any category. Case-insensitive substring matching across category, title and tags, with hyphens and underscores treated as spaces. Combines with searchQuery and locationFilter; text is trimmed to 200 characters.

## `locationFilter` (type: `string`):

Location text, e.g. "USA", "Europe" or "Worldwide"; empty means any location. Case-insensitive substring match in location and locationRestrictions, not a geographic lookup or eligibility guarantee. Combines with other filters; text is trimmed to 200 characters.

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

Maximum jobs saved across all selected sources, e.g. 7. Integer 1-10000, default 50. Not a limit per source. Narrow filters, exhausted feeds or source errors can return fewer jobs. Only saved results are charged.

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

Whether to include description and descriptionHtml, e.g. false for compact rows. Default true. When false both fields are null; keyword filtering still uses available description text. This reduces dataset size, not the number of feed requests.

## `dedupe` (type: `boolean`):

Whether to collapse jobs with the same company, title and apply-link hostname, e.g. false to retain cross-source listings. Default true. Stable duplicate ids are always suppressed even when false; the shared maxItems counts saved rows.

## `salaryOnly` (type: `boolean`):

Whether to keep only jobs with salaryMin, salaryMax or nonempty salaryText, e.g. true for salary research. Default false. Does not estimate missing salaries or compare currencies. Combines with all other filters; set false if too few jobs match.

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

Posting age in days, e.g. 7 for the past week. Integer 0-3650; default 0 disables the filter. Jobs with missing or future dates are excluded when enabled. Uses postedAt, not verified vacancy status. Combines with all other filters; set 0 to broaden results.

## `excludeKeywords` (type: `array`):

Phrases to exclude, e.g. \["unpaid", "commission only"]. Drop jobs containing any phrase in title, company, category, tags or the full available description. Case-insensitive substring matching; each phrase is trimmed to 200 characters. Default \[] excludes nothing. Combines with all other filters.

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

Proxy settings, e.g. {"useApifyProxy": false}. Default: no proxy for public feeds. Enable Apify Proxy on the platform if a source blocks requests. Failed sources are logged and skipped; if none produce jobs the run succeeds with zero rows and guidance to change sources or retry.

## `jobTypes` (type: `array`):

Employment types to keep, e.g. \["full_time", "contract"]. Default \[] accepts every type, including unknown. When selected, match the normalized jobType exactly and exclude jobs without a type. OR within this list, AND with other filters; RemoteOK does not publish jobType.

## `companyKeywords` (type: `array`):

Company name phrases to keep, e.g. \["GitLab", "Automattic"]. Default \[] accepts every company. Case-insensitive substring matching against company only; any phrase may match. AND with other filters. Each phrase is trimmed to 200 characters; empty phrases are ignored.

## Actor input object example

```json
{
  "sources": [
    "remotive",
    "himalayas",
    "jobicy",
    "arbeitnow"
  ],
  "searchQuery": "",
  "category": "",
  "locationFilter": "",
  "maxItems": 40,
  "includeDescription": true,
  "dedupe": true,
  "salaryOnly": false,
  "postedWithinDays": 0,
  "excludeKeywords": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "jobTypes": [],
  "companyKeywords": []
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "sources": [
        "remotive",
        "himalayas",
        "jobicy",
        "arbeitnow"
    ],
    "maxItems": 40,
    "includeDescription": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/remote-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 = {
    "sources": [
        "remotive",
        "himalayas",
        "jobicy",
        "arbeitnow",
    ],
    "maxItems": 40,
    "includeDescription": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/remote-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 '{
  "sources": [
    "remotive",
    "himalayas",
    "jobicy",
    "arbeitnow"
  ],
  "maxItems": 40,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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