# ATS Jobs Scraper & New-Job Monitor (Greenhouse, Lever +6) (`panda_studio/ats-jobs-monitor`) Actor

Scrape jobs from Greenhouse, Lever, Ashby, Workday, Recruitee, Workable, HERP & HRMOS career pages in one schema. Monitor mode returns only new and removed jobs.

- **URL**: https://apify.com/panda\_studio/ats-jobs-monitor.md
- **Developed by:** [panda studio](https://apify.com/panda_studio) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 jobs

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

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

## ATS Jobs Scraper & New-Job Monitor

**ATS Jobs Scraper** collects every open job from company career pages hosted on **Greenhouse, Lever, Ashby, Workday, Recruitee, Workable** and the Japanese ATSs **HERP** and **HRMOS**, and returns them in one normalized schema (title, department, location, remote flag, employment type, posting date, salary when published, apply URL, optional full description). Paste a job-board URL, a `provider:slug` shorthand, or just the company's own careers page — the ATS is detected for you. Turn on **monitor mode** and each run returns only jobs that are **new** or **removed** since the last run, which makes it a cheap hiring-signal and job-alert feed. No login, no proxies, no browser.

### What does ATS Jobs Scraper do?

- Resolves each input to a job board: board URLs (`boards.greenhouse.io/stripe`), shorthands (`lever:palantir`) or a company careers page (`https://www.figma.com/careers/` → Figma's Greenhouse board).
- Downloads all open jobs from that board through the public endpoint the ATS uses to render its own career pages.
- Normalizes the fields across all 8 ATSs, including salary ranges (Ashby, Lever, Recruitee when the company publishes them) and employment types (Japanese values are translated with the original kept, e.g. `Full-time (正社員)`).
- Filters by title keywords, excluded words, location, remote-only and posting age.
- In monitor mode, remembers every job per board and outputs only the changes.

### Who is it for? Use cases

| Who | Use case |
|---|---|
| **B2B sales / SDRs** | Hiring signals: watch 50–500 target accounts and get alerted when one posts "Head of Data" or "Salesforce Admin". Push to Slack, HubSpot or a sheet with Apify integrations. |
| **Recruiters & talent intelligence** | Track which competitors hire for which roles, where, and at what salary band. |
| **Job boards & newsletters** | Build a niche board (remote Rust jobs, AI jobs in Tokyo, ...) from first-party career pages instead of aggregators. |
| **Job seekers** | Get an alert the day a target company opens a matching role. |
| **Japan market research** | HERP and HRMOS power career pages of many Japanese startups and listed companies (e.g. IVRy on HERP, Money Forward on HRMOS). |

### Why use this ATS jobs scraper?

- **8 ATSs, one schema** — including HERP and HRMOS, two Japanese ATSs.
- **Careers-page auto-detection** — paste `https://www.figma.com/careers/` and the Actor finds the embedded Greenhouse board. No need to know which ATS a company uses.
- **Monitor mode with new *and* removed jobs** — detect openings and closings; you pay per company checked plus only the changed jobs.
- **Filters that don't break monitoring** — the memory always tracks the full board, so changing filters later does not produce a flood of "new" jobs.
- **Salary normalization** — `min`, `max`, `currency`, `interval` plus the original text. In a run on 2026-09-24, 310 of 637 jobs (OpenAI on Ashby) came with a salary range.
- **One bad input never fails the run** — errors are listed per board in `RUN_SUMMARY`.
- **Lightweight** — JSON/HTML requests only, 256 MB memory; a Greenhouse/Lever/Ashby board is one request.

### Supported ATS and accepted inputs

| ATS | Example input |
|---|---|
| Greenhouse | `https://boards.greenhouse.io/stripe`, `https://job-boards.greenhouse.io/figma`, `greenhouse:stripe` |
| Lever | `https://jobs.lever.co/palantir`, `lever:palantir` (EU boards: `jobs.eu.lever.co/...`) |
| Ashby | `https://jobs.ashbyhq.com/openai`, `ashby:notion` |
| Workday | `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`, `workday:nvidia.wd5/NVIDIAExternalCareerSite` |
| Recruitee | `https://bunq.recruitee.com`, `recruitee:bunq` |
| Workable | `https://apply.workable.com/skroutz`, `workable:skroutz` |
| HERP (Japan) | `https://herp.careers/v1/ivry`, `herp:ivry` |
| HRMOS (Japan) | `https://hrmos.co/pages/moneyforward/jobs`, `hrmos:moneyforward` |
| Any careers page | `https://www.figma.com/careers/` → detects the embedded board |

### What data do you get?

| Field | Description |
|---|---|
| `provider`, `companySlug`, `companyName` | ATS, board slug and company name |
| `jobId`, `title` | Job ID on the ATS and job title |
| `department`, `team` | Department / team / category as published |
| `location`, `locations`, `country` | Primary location, all locations, country when available |
| `workplaceType`, `isRemote` | `remote` / `hybrid` / `onsite` and a boolean, when the ATS provides it |
| `employmentType` | Normalized, e.g. `Full-time`, `Contract`, `Full-time (正社員)` |
| `postedAt`, `updatedAt` | ISO 8601 timestamps |
| `url`, `applyUrl` | Job page and application page |
| `salary` | `{min, max, currency, interval, text}` when published |
| `tags` | ATS tags/categories |
| `descriptionText` | Plain-text description (when `includeDescription` is on) |
| `changeType`, `firstSeenAt` | `new` / `removed` and first-seen time in monitor mode |
| `scrapedAt`, `sourceInput` | Run timestamp and the input that produced the row |

#### Field availability by ATS

| Field | Greenhouse | Lever | Ashby | Workday | Recruitee | Workable | HERP | HRMOS |
|---|---|---|---|---|---|---|---|---|
| title, url, jobId | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| location | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | – | ✓ |
| department / team | ✓ | ✓ | ✓ | – | ✓ | ✓ | ✓ (group) | ✓ (category) |
| postedAt | ✓ | ✓ | ✓ | ✓ (exact with description) | ✓ | ✓ | – | – |
| employmentType | – | ✓ | ✓ | with description | ✓ | ✓ | – | ✓ |
| salary | – | when published | when published | – | when published | – | – | – |
| descriptionText | ✓ | ✓ | ✓ | ✓ (+1 request/job) | ✓ | ✓ | ✓ (+1 request/job) | summary |

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

Pay per event. Platform usage is included — you only pay these events:

| Event | Price |
|---|---|
| Actor start | $0.00005 per run |
| Company checked (each job board fetched successfully in a run) | $0.001 |
| Result (each job — or each new/removed job in monitor mode — in the dataset) | $0.002 ($2 per 1,000) |

Worked examples (calculated from the prices above):

| Scenario | Jobs output | Cost |
|---|---|---|
| Figma's whole board (160 open jobs on 2026-09-24) | 160 | $0.321 |
| 4 companies with an "engineer" title filter (the example run below) | 637 | $1.278 |
| Monitor 200 companies daily, a day with 30 new/removed jobs | 30 | $0.26 per run |
| Monitor 200 companies daily, a day with no changes | 0 | $0.20 per run (≈ $6 / 30 days) |

The first monitor-mode run outputs all current jobs (that is the baseline); later runs output only changes. Set **Maximum cost per run** in the run options to cap spending — the Actor stops cleanly at the cap.

### How to scrape jobs from Greenhouse, Lever, Ashby, Workday and more

1. Click **Try for free** (an Apify account is free).
2. Add companies to **Company career pages / job boards** — board URLs, `provider:slug`, or careers-page URLs.
3. Optionally set **Title must contain**, **Title must NOT contain**, **Location contains**, **Remote jobs only**, **Posted within last N days**, and **Include full job description**.
4. Click **Start** and download the dataset as JSON, CSV, Excel or HTML.
5. For alerts: turn on **Monitor mode**, give it a **Monitor ID**, save as a Task, add a **Schedule** (e.g. daily 08:00) and an **Integration** (Slack, email, Google Sheets, webhook, Make, Zapier).

### Input example

This is the exact input used for the output example below:

```json
{
  "companies": [
    "https://www.figma.com/careers/",
    "https://jobs.ashbyhq.com/openai",
    "lever:palantir",
    "https://hrmos.co/pages/moneyforward/jobs"
  ],
  "titleKeywords": ["engineer", "エンジニア"],
  "includeDescription": true,
  "maxJobsPerCompany": 1000
}
```

| Input | Default | Notes |
|---|---|---|
| `companies` | — (required) | URLs, `provider:slug`, or careers pages |
| `includeDescription` | false | Adds `descriptionText` (extra request per job on Workday and HERP) |
| `titleKeywords` / `excludeTitleKeywords` | — | Case-insensitive, any of |
| `locationKeywords` | — | Location contains any of |
| `remoteOnly` | false | Only jobs marked remote |
| `postedWithinDays` | 0 | 0 = no limit |
| `maxJobsPerCompany` | 1000 | Cap per board |
| `monitorMode` / `monitorId` | false / — | Output only changes since the last run |
| `emitRemoved` | true | Also output removed (closed) jobs in monitor mode |
| `requestIntervalSecs` | 0.5 | Pause between requests |

### Output example

Real output from a run on 2026-09-24 with the input above: 4 boards, 637 matching jobs, 0 errors, 13 s. Descriptions are shortened here.

Ashby (OpenAI) — with a salary range:

```json
{
  "provider": "ashby",
  "companySlug": "openai",
  "companyName": "openai",
  "jobId": "240d459b-696d-43eb-8497-fab3e56ecd9b",
  "title": "Research Engineer",
  "department": "Research",
  "team": "Research",
  "location": "San Francisco",
  "locations": ["San Francisco"],
  "country": "United States",
  "workplaceType": null,
  "isRemote": null,
  "employmentType": "Full-time",
  "postedAt": "2025-04-05T00:03:20+00:00",
  "updatedAt": null,
  "url": "https://jobs.ashbyhq.com/openai/240d459b-696d-43eb-8497-fab3e56ecd9b",
  "applyUrl": "https://jobs.ashbyhq.com/openai/240d459b-696d-43eb-8497-fab3e56ecd9b/application",
  "salary": {"min": 250000, "max": 445000, "currency": "USD", "interval": "1 YEAR", "text": "$250K – $445K • Offers Equity"},
  "tags": [],
  "descriptionText": "By applying to this role, you will be considered for Research Engineer roles across all teams at OpenAI. ...",
  "scrapedAt": "2026-09-24T14:20:04+00:00",
  "sourceInput": "https://jobs.ashbyhq.com/openai",
  "changeType": null,
  "firstSeenAt": null
}
```

Greenhouse (found from `https://www.figma.com/careers/`):

```json
{
  "provider": "greenhouse",
  "companySlug": "figma",
  "companyName": "Figma",
  "jobId": "6178851004",
  "title": "Data Engineer Intern (2027)",
  "department": "Early Career",
  "location": "San Francisco, CA • New York, NY",
  "locations": ["San Francisco, CA • New York, NY", "US"],
  "postedAt": "2026-09-23T19:30:27+00:00",
  "url": "https://boards.greenhouse.io/figma/jobs/6178851004?gh_jid=6178851004",
  "sourceInput": "https://www.figma.com/careers/"
}
```

Lever (Palantir) — workplace type and country:

```json
{
  "provider": "lever",
  "companySlug": "palantir",
  "title": "Backend Software Engineer - Application Development",
  "team": "Dev",
  "location": "London, United Kingdom",
  "country": "GB",
  "workplaceType": "hybrid",
  "isRemote": false,
  "employmentType": "Full-time",
  "url": "https://jobs.lever.co/palantir/10dfc8bc-99ad-4ca2-ab76-853cb90a92c2",
  "applyUrl": "https://jobs.lever.co/palantir/10dfc8bc-99ad-4ca2-ab76-853cb90a92c2/apply"
}
```

HRMOS (Money Forward) — Japanese employment type translated, original kept:

```json
{
  "provider": "hrmos",
  "companyName": "株式会社マネーフォワード",
  "jobId": "0004175",
  "title": "【エンジニア】オープンポジション_（東京・大阪・京都・名古屋・福岡）",
  "department": "エンジニア",
  "location": "東京都港区芝浦3-1-21 msb Tamachi 田町ステーションタワーS 21F",
  "employmentType": "Full-time (正社員)",
  "tags": ["エンジニア", "オープン", "日本語", "オープンポジション（エンジニア）", "正社員"],
  "url": "https://hrmos.co/pages/moneyforward/jobs/0004175"
}
```

`RUN_SUMMARY` (default key-value store) from the same run, shortened:

```json
{
  "durationSecs": 13.0,
  "boards": [
    {"board": "greenhouse::figma", "status": "ok", "openJobs": 160, "output": 32, "removed": 0},
    {"board": "ashby::openai", "status": "ok", "openJobs": 828, "output": 365, "removed": 0},
    {"board": "lever::palantir", "status": "ok", "openJobs": 318, "output": 193, "removed": 0},
    {"board": "hrmos::moneyforward", "status": "ok", "openJobs": 47, "output": 47, "removed": 0}
  ],
  "errors": [],
  "resultsPushed": 637
}
```

### Monitor mode (new job alerts and hiring signals)

1. Set `monitorMode: true` and give the watch list a `monitorId`.
2. The first run outputs every open job and remembers them in a named key-value store in your own account (`ats-jobs-monitor-state`).
3. Every later run outputs only:
   - `changeType: "new"` — jobs that were not on the board last time
   - `changeType: "removed"` — jobs that disappeared (closed or filled), if `emitRemoved` is on
4. If nothing changed, the dataset is empty and you pay only the start and company-checked events.

Filters only affect what is output; the memory always tracks the whole board.

### Tips

- Leave `includeDescription` off for monitoring large Workday boards — it adds one request per job there.
- Use `excludeTitleKeywords` (e.g. `intern`, `senior`) to cut noise.
- Not sure of the slug? Paste the company's careers page URL.
- One Task per watch list (e.g. "target accounts", "competitors") keeps the monitor state separate.

### Integrations & API usage

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("panda_studio/ats-jobs-monitor").call(run_input={
    "companies": ["greenhouse:stripe", "https://jobs.ashbyhq.com/notion"],
    "titleKeywords": ["engineer"],
    "monitorMode": True,
    "monitorId": "my-accounts",
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["changeType"], job["companyName"], job["title"], job["url"])
```

Node.js:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('panda_studio/ats-jobs-monitor').call({
    companies: ['greenhouse:stripe', 'lever:palantir'],
    remoteOnly: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

cURL (run and get the items in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/panda_studio~ats-jobs-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["greenhouse:stripe"], "titleKeywords": ["engineer"]}'
```

MCP (Claude, Cursor, VS Code and other AI agents):

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=panda_studio/ats-jobs-monitor" }
  }
}
```

### Is it legal to scrape ATS job listings?

The Actor reads the same public job listings anyone can see on a company's career page, through the endpoints the ATS vendors provide for that purpose: Greenhouse Job Board API, Lever Postings API, Ashby job-posting API, Recruitee and Workable career-site APIs, Workday career-site JSON, and the public HERP and HRMOS career pages. It never logs in. robots.txt is checked at run time for Workday, HERP and careers-page detection. SmartRecruiters is not supported because its robots.txt disallows generic crawlers. Job postings are company information, not personal data. You are responsible for how you use the data.

### FAQ

**A board returns 404.** The slug is wrong or the company moved to another ATS. Paste the company's careers page URL instead and the Actor will detect the current board.

**Which ATS does a company use?** Paste its careers page; the detected board appears in `RUN_SUMMARY` (e.g. `greenhouse::figma`).

**How fast is it?** Greenhouse, Lever, Ashby, Recruitee and Workable boards are one request each. Workday returns 20 jobs per request and HRMOS 100 per page. The 4-board example above took 13 s including descriptions.

**Why does `companyName` show the slug?** Lever and Ashby do not publish a display name in their API, so the slug is used.

**Is salary always available?** No — only when the company publishes it on Ashby, Lever or Recruitee.

**Do I pay for unchanged jobs in monitor mode?** No. After the first (baseline) run you pay $0.001 per company checked plus $0.002 per new or removed job.

**Can I add other ATSs (iCIMS, SmartRecruiters, Personio...)?** Not currently. SmartRecruiters is excluded because of its robots.txt.

**Does it collect personal data?** No. Only job postings (company information).

### Changelog

- 0.1 — Initial release: 8 ATSs, careers-page auto-detection, filters, monitor mode with new/removed jobs, cost-cap aware stopping.

# Actor input Schema

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

One entry per company. Paste the job-board URL (e.g. <code>https://boards.greenhouse.io/stripe</code>, <code>https://jobs.lever.co/palantir</code>, <code>https://jobs.ashbyhq.com/openai</code>, <code>https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite</code>, <code>https://bunq.recruitee.com</code>, <code>https://apply.workable.com/skroutz</code>, <code>https://herp.careers/v1/ivry</code>, <code>https://hrmos.co/pages/moneyforward/jobs</code>), a shorthand like <code>greenhouse:stripe</code>, or the company's own careers page URL - the Actor will look for an embedded ATS board on that page.

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

Adds the plain-text job description to every result. For Workday and HERP this needs one extra request per job, so runs are slower.

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

Keep only jobs whose title contains at least one of these words (case-insensitive). Example: <code>engineer</code>, <code>data</code>, <code>エンジニア</code>. Leave empty to keep all.

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

Drop jobs whose title contains any of these words. Example: <code>intern</code>, <code>senior</code>.

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

Keep only jobs whose location or country contains one of these strings. Example: <code>tokyo</code>, <code>japan</code>, <code>remote</code>, <code>東京</code>.

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

Keep only jobs flagged as remote by the ATS (or with 'remote'/'リモート' in the location/tags).

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

Keep only jobs published within the last N days (jobs without a publish date are kept). 0 = no limit.

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

Safety cap per company board. 0 = no cap.

## `monitorMode` (type: `boolean`):

Remembers every job it has seen (in a named key-value store in your account). On later runs only jobs that were not there before are returned (<code>changeType: new</code>), plus jobs that disappeared (<code>changeType: removed</code>). The first run returns everything. Schedule the Actor daily to get hiring alerts - you only pay for the changes.

## `monitorId` (type: `string`):

Name for this watch list. Runs with the same Monitor ID share memory. If empty, the ID is derived from the list of companies.

## `emitRemoved` (type: `boolean`):

In monitor mode, output jobs that were open in the previous run but are gone now.

## `requestIntervalSecs` (type: `number`):

Politeness delay between HTTP requests. Minimum 0.2.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.ashbyhq.com/notion",
    "lever:palantir"
  ],
  "includeDescription": false,
  "remoteOnly": false,
  "postedWithinDays": 0,
  "maxJobsPerCompany": 1000,
  "monitorMode": false,
  "emitRemoved": true,
  "requestIntervalSecs": 0.5
}
```

# Actor output Schema

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

One item per job posting, stored in the default dataset.

## `runSummary` (type: `string`):

Per-board counts and any errors.

# 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://boards.greenhouse.io/stripe",
        "https://jobs.ashbyhq.com/notion",
        "lever:palantir"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("panda_studio/ats-jobs-monitor").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://boards.greenhouse.io/stripe",
        "https://jobs.ashbyhq.com/notion",
        "lever:palantir",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("panda_studio/ats-jobs-monitor").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://boards.greenhouse.io/stripe",
    "https://jobs.ashbyhq.com/notion",
    "lever:palantir"
  ]
}' |
apify call panda_studio/ats-jobs-monitor --silent --output-dataset

```

## MCP server setup

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

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/7BNtUT2dfSXbY289d/builds/sFkBNcKZG61TPgIrl/openapi.json