# Wellfound (AngelList) Jobs, Companies, Salary & Equity Scraper (`brilliant_gum/wellfound-jobs-scraper`) Actor

Scrape Wellfound (AngelList) startup jobs, companies, salaries and equity — no login. Four modes (search, job-details, company-jobs, company-details) with parsed salary + equity ranges, funding stage, company size, markets, seniority inference, dedup, monitoring and a run analytics summary.

- **URL**: https://apify.com/brilliant\_gum/wellfound-jobs-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Stats:** 3 total users, 2 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.012 / result record

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Wellfound (AngelList) Jobs Scraper — startup jobs, salary & equity, company data (no login)

Scrape startup jobs from **Wellfound** (formerly **AngelList Talent**) with **parsed salary and equity**, plus company **funding stage, size, and markets** — **no login, no API key, no cookies**. HTTP-first (no browser), fast, and parallel-friendly.

![Wellfound Jobs Scraper](https://api.apify.com/v2/key-value-stores/IuFu0Cw6PpOkNkDV7/records/wellfound-jobs-scraper-banner.png)

> **Enjoying this Actor?** If it's useful, please leave a ⭐️ rating and a short review — it genuinely helps. **Something not working right?** Open an issue on the Actor's **Issues** tab — I actively maintain this Actor and respond fast to fix problems and help you get things working.

Wellfound packs compensation into a single human string like `"$80k – $90k • 5.0% – 10.0%"`. This actor splits that into structured `salary {min, max, currency, period}` **and** `equity {min, max, hasEquity}`, then enriches every posting with the company's funding stage, size, markets, badges, and social links. Built for **recruiters**, **job seekers**, and **startup / market researchers** who need clean, structured startup-hiring data instead of raw HTML.

***

### Key features

- **4 scraping modes in one actor** — `search` (jobs by role / location / remote), `job-details` (one record per job URL), `company-jobs` (all live jobs of a company), and `company-details` (a company profile with funding, size, markets, and social — optionally with its jobs).
- **Parsed salary + equity.** Structured `salary {min, max, currency, period}` and **`equity {min, max %, hasEquity}`** from Wellfound's combined compensation string. Currency-aware (`$` USD, `£` GBP, `€` EUR, `₹` INR, `¥` JPY) and unit-aware, including **Indian lakh/crore notation** — `₹5.5L` → `550000`, `₹2cr` → `20000000`.
- **Company enrichment** — funding **stage** (Early Stage, Growth Stage…), **size** (`11-50`, `501-1000`…), **markets/industries**, **badges** (Actively Hiring, B2B, Growing fast…), tagline, website, **social links** (Twitter, LinkedIn, Facebook, blog, Product Hunt), live-jobs count, and per-role / per-location / per-type job counts.
- **Seniority inference** — every job title is classified (`intern`, `junior`, `mid`, `senior`, `staff`, `lead`, `manager`, `principal`, `director`, `executive`).
- **Full job descriptions** in **markdown**, **plain text**, or **HTML**.
- **Cross-run dedup + monitoring mode** — persist seen jobs in a named key-value store and, on scheduled runs, output only *new* postings. Ideal for job alerts.
- **RUN\_SUMMARY analytics** — a per-run roll-up saved to the key-value store: salary/equity coverage, remote share, average salary range, and breakdowns by seniority, job type, company size, and funding stage, plus top markets and companies.
- **Strict superset of the top competitor** — all four navigation modes, the full union of parsed fields, **plus** house extras no competitor ships (seniority inference, cross-run monitoring, and the RUN\_SUMMARY analytics roll-up).
- **No login required.** Public, server-rendered pages only — no account, cookies, or private API.

***

### Input

Configure the run in the Apify Console UI or via JSON / API. Every field is optional; `mode` selects what to scrape and which fields are used.

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `search` | `search` | `job-details` | `company-jobs` | `company-details`. |
| `role` | string | `software engineer` | (search) Role / keyword, e.g. `product designer`. Slugified into Wellfound's `/role/` pages. |
| `roles` | array | – | (search) Several roles in one run (merged + deduped). Max 10. |
| `location` | string | `remote` | (search) City / region, or `remote`. `remote` → `/role/r/{role}`; a city → `/role/l/{role}/{city}`. |
| `locations` | array | – | (search) Several locations in one run. Max 10. |
| `countryName` | string | – | (search) Country, e.g. `India`. Treated as an extra location (Wellfound has no country facet) and merged with `location` / `locations`. |
| `jobUrls` | array | – | (job-details) Job URLs `https://wellfound.com/jobs/{id}-{slug}`, or bare `{id}-{slug}` / numeric id. |
| `companies` | array | – | (company-jobs / company-details) Company slugs (`openai`) or full URLs `https://wellfound.com/company/{slug}`. |
| `remoteOnly` | boolean | `false` | (search) Keep only remote roles. |
| `jobType` | enum | `""` (Any) | Keep only `fulltime` / `parttime` / `contract` / `internship` / `cofounder`. |
| `datePosted` | enum | `""` (Any) | Max age by the posting's live/posted date: `24h` / `3d` / `7d` / `14d` / `30d`. Records with no known date are kept. |
| `maxItems` | integer | `50` | Max job/company records total. `0` = no cap. |
| `maxPages` | integer | `5` | (search) Max result pages per role × location. |
| `descriptionFormat` | enum | `markdown` | `markdown` / `text` / `html`. |
| `parseSalary` | boolean | `true` | Parse the compensation string into structured salary + equity. |
| `includeCompanyJobs` | boolean | `true` | (company-details) Also embed the company's live job listings. |
| `computeAnalytics` | boolean | `true` | Save the `RUN_SUMMARY` roll-up to the key-value store. |
| `deduplicate` | boolean | `true` | Drop duplicates by a `company + title + location` hash (`dedupKey`). |
| `deduplicateKeyStore` | string | – | Named key-value store to persist seen keys across runs. |
| `monitoringMode` | boolean | `false` | Only output records not seen in a prior run (requires `deduplicateKeyStore`). |
| `maxConcurrency` | integer | `5` | Concurrency for page / detail / company fetches. |
| `maxChallengeRetries` | integer | `4` | Retries with fresh proxy sessions on 403/429/5xx/timeout. |
| `proxy` | object | (auto) | Proxies are included and configured automatically — leave the default in place. |

#### Example — search (jobs by role + location)

```json
{
  "mode": "search",
  "role": "software engineer",
  "location": "remote",
  "datePosted": "7d",
  "maxItems": 50,
  "descriptionFormat": "markdown"
}
```

#### Example — job details (by URL)

```json
{
  "mode": "job-details",
  "jobUrls": [
    "https://wellfound.com/jobs/4322508-software-engineer",
    "1234567-product-designer"
  ]
}
```

#### Example — company details (profile + funding + jobs)

```json
{
  "mode": "company-details",
  "companies": ["futurefit-ai-2", "https://wellfound.com/company/openai"],
  "includeCompanyJobs": true
}
```

***

### Output

Results are pushed to the run's dataset (export as JSON, CSV, Excel, etc.). Each record carries a `type` of `job` or `company`.

#### Job record (trimmed)

```json
{
  "mode": "search",
  "type": "job",
  "jobId": "4322508",
  "url": "https://wellfound.com/jobs/4322508-software-engineer",
  "title": "Software Engineer",
  "role": "Software Engineer",
  "company": "FutureFit AI",
  "companyId": "8030547",
  "companySlug": "futurefit-ai-2",
  "companyUrl": "https://wellfound.com/company/futurefit-ai-2",
  "companyWebsite": null,
  "companyLogo": "https://photos.wellfound.com/…",
  "companyTagline": "AI-powered GPS for your Career",
  "companySize": "11-50",
  "companyStage": "Early Stage",
  "companyMarkets": null,
  "companyBadges": ["Actively Hiring", "B2B", "Early Stage", "Growing fast"],
  "location": { "text": "New York City", "city": "New York City", "state": null, "country": null },
  "locationNames": ["New York City"],
  "remote": true,
  "remoteLocations": ["United States"],
  "jobType": "fulltime",
  "seniority": "mid",
  "compensation": "$150k – $185k",
  "salary": { "min": 150000, "max": 185000, "currency": "USD", "period": "yearly", "source": "wellfound" },
  "equity": null,
  "atsSource": "Ashby",
  "postedAt": "2026-09-02",
  "postedTimestamp": 1788307200,
  "description": "…",
  "dedupKey": "…",
  "scrapedAt": "2026-09-06T…Z"
}
```

**Job fields:** `mode`, `type`, `jobId`, `url`, `title`, `role`, `roleParent`, `company`, `companyId`, `companySlug`, `companyUrl`, `companyWebsite`, `companyLogo`, `companyTagline`, `companySize`, `companyStage`, `companyMarkets`, `companyBadges`, `location {text, city, state, country}`, `locationNames`, `remote`, `remoteLocations`, `jobType`, `seniority`, `yearsExperienceMin`, `yearsExperienceMax`, `compensation`, `salary {min, max, currency, period, source}`, `equity {min, max, hasEquity}`, `description`, `atsSource`, `autoPosted`, `postedAt`, `postedTimestamp`, `dedupKey`, `scrapedAt`. Job-details records also add `industry` and `directApply`.

> When the employer discloses equity, `equity` is populated — e.g. a `"$80k – $90k • 5.0% – 10.0%"` posting yields `"equity": { "min": 5, "max": 10, "hasEquity": true }`.

#### Company record (company-details, trimmed)

```json
{
  "mode": "company-details",
  "type": "company",
  "companyId": "8030547",
  "name": "FutureFit AI",
  "slug": "futurefit-ai-2",
  "url": "https://wellfound.com/company/futurefit-ai-2",
  "website": "https://www.futurefit.ai/",
  "logo": "https://photos.wellfound.com/…",
  "tagline": "AI-powered GPS for your Career",
  "size": "11-50",
  "stage": "Early Stage",
  "hiring": true,
  "liveJobsCount": 10,
  "totalRaised": null,
  "markets": ["SaaS", "Hr Tech"],
  "locations": ["Canada"],
  "badges": ["Actively Hiring", "B2B", "Early Stage", "Growing fast"],
  "social": { "twitter": null, "linkedin": null, "facebook": null, "blog": null, "productHunt": null },
  "jobCountsByRole": [{ "name": "Engineering", "count": 3 }],
  "jobCountsByLocation": [{ "name": "New York City", "count": 6 }],
  "metaDescription": "…",
  "jobs": [ "…job records…" ],
  "scrapedAt": "2026-09-06T…Z"
}
```

**Company fields:** `mode`, `type`, `companyId`, `name`, `slug`, `url`, `website`, `logo`, `tagline`, `size`, `stage`, `hiring`, `liveJobsCount`, `totalRaised`, `markets`, `locations`, `badges`, `social {twitter, linkedin, facebook, blog, productHunt}`, `jobCountsByRole`, `jobCountsByLocation`, `jobCountsByType`, `metaDescription`, `jobs`, `scrapedAt`.

#### RUN\_SUMMARY (key-value store)

Each run also saves a `RUN_SUMMARY` record. Real values from a `software engineer` / `remote` run:

```json
{
  "mode": "search",
  "roles": ["software engineer"],
  "locations": ["remote"],
  "totalCollected": 187,
  "totalOutput": 26,
  "withSalary": 22,
  "withEquity": 3,
  "salaryCoverage": 0.85,
  "equityCoverage": 0.12,
  "remoteShare": 1,
  "avgSalaryMin": 135909,
  "avgSalaryMax": 183682,
  "bySeniority": { "mid": 10, "senior": 10, "staff": 4, "manager": 1, "lead": 1 },
  "byJobType": { "fulltime": 26 },
  "byCompanySize": { "11-50": 11, "201-500": 6, "501-1000": 4, "51-200": 3, "1-10": 2 },
  "byStage": { "Growth Stage": 9, "Early Stage": 6 },
  "topCompanies": [{ "name": "LawnStarter", "count": 3 }, { "name": "Bask Health", "count": 3 }],
  "topMarkets": [],
  "duplicatesDropped": 0,
  "pagesFetched": 5,
  "blocked": []
}
```

***

### Pricing

This actor uses Apify's **pay-per-event** model: a small **start fee per run** plus a **per-result charge** for every record (job or company) pushed to your dataset — on top of your own Apify platform usage (compute + proxy). There are no monthly minimums, and the per-result charge is the dominant cost. The exact start fee and per-result rate are shown on the actor's **Pricing** tab in the Apify Store. Use `maxItems` to cap the number of results (and therefore your spend) on any run.

***

### Use cases

- **Startup hiring intelligence** — track which startups are actively hiring, at what stage and size, and in which markets. Watch a competitor set with `company-jobs` / `company-details`.
- **Salary & equity benchmarking** — build compensation benchmarks by role, seniority, location, and funding stage using the structured `salary` + `equity` fields (including Indian `₹` lakh/crore postings).
- **Candidate & talent sourcing** — pull fresh, structured job feeds by role and location; run on a schedule with `monitoringMode` to surface only *new* postings for alerts.
- **Market & ecosystem mapping** — map startups by funding stage, size, and market/industry tags; roll up hiring signals across a sector with the RUN\_SUMMARY analytics.

***

### Honest limitations

We would rather set expectations correctly than overpromise. Wellfound has strong anti-bot protection, which shapes what is reachable and how fast:

- **Proxies are automatic.** No proxy setup is needed — proxies are included and configured for you (leave the `proxy` input on its default). **Company pages** (`/company/*`) are heavier and **slower (~30 s per company page)** than the search / job-detail pages.
- **Equity is `null` when undisclosed.** Only a minority of employers publish equity. In a sample `software engineer` remote run, **only 12% of postings disclosed equity** (salary coverage was 85%). When it isn't disclosed, `equity` is `null`.
- **`companyMarkets` and `companyWebsite` are `null` in `search` mode — by construction.** Wellfound's SEO search pages embed a slim company node (name, slug, size, stage, badges, tagline, logo) with **no markets and no website**, and there is no full company entity on the page to backfill from. To get a company's markets and website, run **company-details** or **company-jobs** for that company.
- **`job-details` mode returns a lighter company profile.** A single job page carries the posting + salary + company name/website/markets, but not the full company entity — so `companyId`, `companySize`, `companyStage`, `companyBadges` and `companyTagline` are `null` there. Use **company-details** / **company-jobs** for the full company enrichment.
- **`totalRaised` is populated when Wellfound publishes it, else `null`.** Company pages often expose a total-raised amount (e.g. `23850000`); when a company doesn't publish one, we emit `null` (undisclosed) rather than a misleading `0`, and `companyStage` / `stage` is always available as the funding signal. In `search` mode the amount isn't on the page, so run **company-details** for it.
- **Search returns highlighted jobs.** Search pages surface each startup's *highlighted* listings (Wellfound's own SEO page contents), typically the most relevant/recent per company. To enumerate *all* of one company's live jobs, use **company-jobs** mode.
- A blocked page is recorded in `RUN_SUMMARY.blocked[]` and skipped — it never fails the whole run.

***

### FAQ

**Do I need a Wellfound / AngelList account or login?**
No. The actor reads only public, server-rendered pages — no account, cookies, or private API.

**Do I need to set up proxies?**
No — proxies are included and configured automatically; just leave the `proxy` input on its default. Company pages are heavier, so those runs take a bit longer.

**Which mode should I use?**
`search` for role/location/remote discovery, `job-details` for specific job URLs, `company-jobs` for a company's full live listings, and `company-details` for a company's profile (funding stage, size, markets, social).

**Can I get only new jobs on a schedule?**
Yes. Set a `deduplicateKeyStore` and enable `monitoringMode` — scheduled runs then output only postings not seen before, which is ideal for alerts.

**How is salary parsed for Indian postings?**
`₹`, lakh, and crore are supported: `L` / `lakh` / `lac` = ×100,000 and `cr` / `crore` = ×10,000,000. So `₹5.5L – ₹8L` → `{ min: 550000, max: 800000, currency: "INR" }`.

**In which formats can I export results?**
Any Apify dataset format — JSON, CSV, Excel, XML, or via the API. Job descriptions can be markdown, plain text, or HTML.

***

### Legal / ToS

Public data only — no login, no cookies, no private API. The actor parses the same server-rendered pages a logged-out browser receives. Personal data is limited to what employers publish in their postings. You are responsible for complying with Wellfound's Terms of Service and applicable laws (including GDPR/CCPA) when using the collected data.

# Actor input Schema

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

What to scrape. 'search' = jobs by role/location/remote; 'job-details' = one record per Wellfound job URL; 'company-jobs' = all live jobs of a company; 'company-details' = a company profile (funding, size, markets, social) optionally with its jobs.

## `role` (type: `string`):

(search) Role or keyword to search, e.g. "software engineer", "product designer". Slugified into Wellfound's /role/ SEO pages. Required for search unless a location is given.

## `roles` (type: `array`):

(search) Optional. Several roles searched in one run (results merged + deduped). Max 10. Leave empty to use the single role above.

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

(search) City / region, or "remote". "remote" -> /role/r/{role}; a city -> /role/l/{role}/{city}. Empty = anywhere.

## `locations` (type: `array`):

(search) Optional. Several locations searched in one run (results merged + deduped). Max 10.

## `countryName` (type: `string`):

(search) Optional country to search in, e.g. "India", "United States". Treated as an additional location (Wellfound has no separate country facet), merged with location / locations.

## `jobUrls` (type: `array`):

(job-details) Wellfound job URLs (https://wellfound.com/jobs/{id}-{slug}), or bare "{id}-{slug}" / numeric id. Each yields one detailed job record parsed from the job page's schema.org data.

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

(company-jobs / company-details) Company slugs (e.g. "openai") or full URLs (https://wellfound.com/company/{slug}). Company pages are heavier and take longer than search/job pages.

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

(search) Keep only remote roles (forces the /role/r/ remote search and filters the results).

## `jobType` (type: `string`):

Keep only this employment type. "Any" returns all types.

## `datePosted` (type: `string`):

Keep only jobs posted within this window (by the posting's live/posted date). "Any time" disables the filter. Records with no known posted date are always kept.

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

Maximum job/company records to output in total. 0 = no cap.

## `maxPages` (type: `integer`):

(search) Max result pages to fetch per role x location. Each page carries ~20 startups' worth of highlighted jobs. Capped by the page count Wellfound reports.

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

Output format for job descriptions. Wellfound serves markdown; 'text' strips it, 'html' renders it.

## `parseSalary` (type: `boolean`):

Parse the combined compensation string (e.g. "$80k – $90k • 5.0% – 10.0%") into structured salary{min,max,currency,period} and equity{min,max,hasEquity}.

## `includeCompanyJobs` (type: `boolean`):

(company-details) Also embed the company's live job listings inside the company record.

## `computeAnalytics` (type: `boolean`):

Save a RUN\_SUMMARY record (counts, salary/equity coverage, remote share, average salary, seniority/job-type/size/stage breakdown, top markets + companies, blocked pages) to the key-value store.

## `deduplicate` (type: `boolean`):

Drop duplicate records using a company+title+location hash (dedupKey).

## `deduplicateKeyStore` (type: `string`):

Named key-value store to persist seen dedupKeys across scheduled runs. Empty = in-run dedup only.

## `monitoringMode` (type: `boolean`):

Only output records not seen in a previous run (requires a cross-run dedup key store). Great for scheduled new-job alerts.

## `maxConcurrency` (type: `integer`):

Concurrency for page / detail / company fetches.

## `maxChallengeRetries` (type: `integer`):

Retry attempts with fresh proxy sessions on temporary failures (403/429/5xx/timeout).

## `proxy` (type: `object`):

Proxies are included and configured automatically — leave the default in place.

## Actor input object example

```json
{
  "mode": "search",
  "role": "software engineer",
  "location": "remote",
  "remoteOnly": false,
  "jobType": "",
  "datePosted": "",
  "maxItems": 50,
  "maxPages": 5,
  "descriptionFormat": "markdown",
  "parseSalary": true,
  "includeCompanyJobs": true,
  "computeAnalytics": true,
  "deduplicate": true,
  "monitoringMode": false,
  "maxConcurrency": 5,
  "maxChallengeRetries": 4,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All job and company records produced by the run.

# 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 = {
    "role": "software engineer",
    "location": "remote",
    "maxItems": 50,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/wellfound-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 = {
    "role": "software engineer",
    "location": "remote",
    "maxItems": 50,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/wellfound-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 '{
  "role": "software engineer",
  "location": "remote",
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call brilliant_gum/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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