# Indeed Email Scraper Fast Advanced And Cheapest (`scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest`) Actor

Indeed Email Scraper extracts recruiter and employer emails by keyword, location or custom domain, returning network, title, description, URL and email. 🧑‍💼 Fast, low-cost sourcing for recruiters, staffing agencies and B2B sales teams.

- **URL**: https://apify.com/scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### 📬 Indeed Email Scraper – Fast Keyword-Based Email Extraction for Recruitment Leads

The Indeed Email Scraper extracts email addresses published on Indeed listings using the keywords and email domains you choose, turning a job-board search into a contactable lead list. Give it a set of search terms such as `manager` or `founder`, optionally a location, and a list of email domains like `@gmail.com` — the scraper works through public search results and returns every matching address alongside the listing title, description snippet and source URL it came from.

Recruitment data is only useful if you can act on it. A job listing tells you a role exists; an email address tells you where to send the candidate, the pitch or the enquiry. This Indeed email scraper closes that gap by pulling contact addresses out of publicly indexed Indeed pages, attributing each one to the keyword that surfaced it, so you always know which slice of your search produced which lead.

***

### 📊 What Data Can You Extract with This Indeed Email Scraper?

Every dataset item is one email address in the context of the listing that published it. The six fields group as follows.

| Category | Fields | What it gives you |
| --- | --- | --- |
| ✉️ Contact | `email` | The email address extracted from the listing — the payload of every row |
| 🔎 Search provenance | `keyword` | The search term from your input that produced this result, so you can measure which keywords convert |
| 🌐 Source network | `network` | The network the listing belongs to, reported as `Indeed.com` |
| 📝 Listing content | `title`, `description` | The listing headline and the surrounding descriptive text, giving context on the role or company |
| 🔗 Verification link | `url` | The source URL of the listing, so any address can be traced back and verified manually |
| 📥 Volume control | governed by `maxEmails` | A hard ceiling on how many addresses a run collects, keeping cost and duration predictable |

The under-appreciated field here is `keyword`. Because every row records the exact term that surfaced it, you can compute yield per keyword after a run — how many usable addresses `founder` produced versus `manager` — and then invest your next run's budget in the terms that actually work rather than guessing.

***

### 🌟 Key Features of the Indeed Email Scraper

| Feature | Description |
| --- | --- |
| 🔑 Multi-keyword search | Pass an array of keywords or full queries; the scraper works through each one and tags every result with the term that produced it |
| 🎯 Email domain targeting | The `customDomains` input restricts extraction to addresses at the domains you specify, for example `@gmail.com` and `@yahoo.com` |
| 📍 Location filtering | An optional `location` string narrows results to a city, region or country, which matters for geographically constrained hiring |
| 🛑 Hard email budget | `maxEmails` stops the run the moment your target number of addresses is reached, capping both time and spend |
| 🔁 Duplicate suppression | Addresses already seen within a run are skipped, so the dataset contains distinct emails rather than repeats of the same contact |
| 💾 Resumable progress | The scraper tracks its position across keywords and domains, so an interrupted run does not restart from zero |
| 🔀 Automatic proxy rotation | Requests are routed through rotating proxies automatically, which keeps large keyword sweeps stable without any configuration on your part |
| ⚡ Asynchronous HTTP engine | Built on `aiohttp` with `parsel` parsing rather than a headless browser, so runs are quick and resource-light |
| 📤 Streaming dataset writes | Each address is pushed to the Apify dataset as it is found, meaning partial results are available even if you abort mid-run |

***

### 🚀 Why Choose This Indeed Email Scraper?

**Keyword attribution built into every row.** Most email scrapers hand back an undifferentiated list. Here, `keyword` travels with every record, which makes the output measurable: you can rank search terms by yield, drop the ones producing nothing, and turn lead generation into an iterative process rather than a lottery.

**Domain targeting keeps lists relevant.** Filtering to specific email domains through `customDomains` means you decide upfront whether you want consumer addresses, a particular corporate domain, or a mix. That single control removes most of the noise that makes generic email extraction unusable.

**A real spend ceiling.** `maxEmails` is a stop condition, not a post-run filter. When the target count is hit the scraper stops working, so a run configured for twenty addresses does twenty addresses' worth of work. This is what makes budgeting across many small runs practical.

**Context alongside the address.** Every row carries `title`, `description` and `url`. You are not just getting an address in a vacuum — you get the listing text it appeared in and a link to verify it, which is the difference between a lead you can personalise and a cold string in a spreadsheet.

***

### 📥 Input

The Indeed email scraper takes your keywords, an optional location, the email domains to target and a maximum number of addresses.

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

#### 🔧 Indeed Email Scraper Input Fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `keywords` | array | ✅ Yes | `["manager", "founder"]` | A list of keywords or queries to search for. Entered as a string list, one term per line. |
| `location` | string | ❌ No | `""` | Location used to filter search results. Leave empty for no geographic restriction. |
| `customDomains` | array | ❌ No | `["@gmail.com", "@yahoo.com"]` | List of custom email domains to target during extraction. |
| `maxEmails` | integer | ❌ No | `20` | Maximum number of emails to collect. The scraper stops once this limit is reached. Minimum `1`, maximum `10000`. Setting a higher limit allows more potential results but does not guarantee reaching that number — it helps control scraping time and cost. |

#### 💡 Input Examples

**Targeted local recruitment search**

```json
{
  "keywords": ["warehouse manager", "logistics coordinator"],
  "location": "Manchester",
  "customDomains": ["@gmail.com"],
  "maxEmails": 50
}
```

**Founder and executive prospecting**

```json
{
  "keywords": ["founder", "co-founder", "managing director"],
  "customDomains": ["@gmail.com", "@yahoo.com", "@outlook.com"],
  "maxEmails": 200
}
```

**Small test run before committing budget**

```json
{
  "keywords": ["recruiter"],
  "maxEmails": 5
}
```

***

### 📤 Output

Each item pairs an extracted email address with the listing context it came from.

```json
{
  "network": "Indeed.com",
  "keyword": "founder",
  "title": "Founder & Managing Director – Growth Consultancy",
  "description": "We are a small consultancy looking to expand our advisory team. Applications and enquiries to the address below.",
  "url": "https://www.indeed.com/viewjob?jk=example123",
  "email": "example.contact@gmail.com"
}
```

#### 🧾 Indeed Email Scraper Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | null | The network the listing belongs to, reported as `Indeed.com` |
| `keyword` | string | null | The keyword from your input that produced this item |
| `title` | string | null | Title of the listing the address was found on |
| `description` | string | null | Long-form description text surrounding the listing |
| `url` | string | null | Canonical URL of the scraped listing |
| `email` | string | null | Email address found for the item |

Rows are written to the dataset as they are discovered rather than in one batch at the end, so you can watch results accumulate live and still keep everything collected so far if you abort the run early.

***

### 💻 How to Use the Indeed Email Scraper (Step by Step)

#### Step 1: Open the Indeed Email Scraper on Apify

Sign in to Apify and open the Indeed Email Scraper Actor. Everything executes on Apify's infrastructure, so there is no local setup, no proxy account to arrange and no Python environment to maintain. The Actor page gives you a form-based input editor, a live log and a dataset view that fills as addresses are found.

#### Step 2: Choose Your Keywords Carefully

The **Keywords or Queries** field is where most of your result quality is decided. Broad terms such as `manager` return volume but low relevance; specific role titles combined with an industry word return fewer but far better matches. Add several related terms rather than one — the scraper tags each result with its source keyword, so you lose nothing by testing multiple angles in a single run.

#### Step 3: Set a Location If Geography Matters

If you are recruiting for a specific city or region, enter it in the **Location** field. Leaving it empty runs an unrestricted search, which is right for remote roles or when you are prospecting rather than hiring. Be aware that narrowing by location reduces the pool substantially, so pair a tight location with broader keywords.

#### Step 4: Define the Email Domains You Want

Set `customDomains` to the domains you are actually interested in. The defaults, `@gmail.com` and `@yahoo.com`, target consumer addresses, which is usually what you want when the contact is an individual rather than a company inbox. Add corporate domains if you are prospecting into specific organisations, and keep the list short — every additional domain multiplies the work per keyword.

#### Step 5: Set Your Email Budget

`maxEmails` is your cost and time control. Start low — five or ten — to validate that your keyword and domain combination produces anything usable, then re-run with a higher limit once you know the configuration works. A failed run at `maxEmails: 5` costs almost nothing; a failed run at `maxEmails: 5000` does not.

#### Step 6: Run and Monitor the Log

Press **Start**. The log reports each address as it is found and pushed, along with progress through the keyword and domain combinations. Because the scraper persists its cursor, an interrupted run resumes rather than starting over. If the log shows the email limit being reached, the run stops cleanly at that point.

#### Step 7: Clean, Verify and Export

Open the **Dataset** tab and review the results before use. Deduplicate on `email`, spot-check a handful of `url` values to confirm the addresses genuinely appear on those listings, and run a syntax and MX validation pass before anything reaches an outreach platform. Then export as CSV, XLSX or JSON, or wire the Actor into an integration for recurring runs.

***

### 🔌 API Access & Integrations

Trigger the Indeed email scraper and get the dataset back in a single request:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~indeed-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["manager", "founder"],
    "location": "",
    "customDomains": ["@gmail.com", "@yahoo.com"],
    "maxEmails": 20
  }'
```

The equivalent using the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest").call(
    run_input={
        "keywords": ["manager", "founder"],
        "customDomains": ["@gmail.com"],
        "maxEmails": 50,
    }
)

by_keyword = {}
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    by_keyword.setdefault(item["keyword"], []).append(item["email"])

for keyword, emails in by_keyword.items():
    print(keyword, len(emails))
```

Results can also be pushed automatically to Zapier, Make, Google Sheets and Slack, or to any endpoint you control via Apify webhooks that fire on run completion.

***

### 💡 Best Use Cases for Indeed Email Data

#### 🧑‍💼 Recruitment Agency Lead Generation

Agencies need a pipeline of employers who are actively hiring. Searching role keywords in a target sector and keeping the rows where `title` matches your specialism produces a list of live opportunities with a contact address attached, and the `url` lets a consultant read the full listing before making an approach.

#### 📈 Sales Prospecting into Hiring Companies

A company advertising for a role is a company with budget and an unsolved problem. Filtering results by `keyword` terms that indicate growth — `founder`, `head of`, `director` — surfaces organisations in an expansion phase, which is a far stronger buying signal than firmographic data alone.

#### 🛠️ Staffing and Contract Placement

Contract staffing depends on speed. Running a tight keyword set with a specific `location` on a schedule gives you a daily feed of newly published opportunities with contacts attached, letting you approach hiring managers before the role reaches the wider market.

#### 📊 Labour Market and Hiring Trend Research

The `keyword`, `title` and `description` fields together support genuine market analysis. Tracking how many results a given role keyword returns week over week is a rough but useful proxy for hiring demand in that discipline, and the description text can be mined for skills and technology mentions.

#### 🎓 Career Services and Candidate Support

University careers teams and outplacement consultants can assemble region-specific opportunity lists for their cohorts. Filtering on `location` and a discipline keyword produces a curated set of listings with contact routes, which is more actionable than a generic job-board link.

#### 🏢 Employer Branding and Competitive Intelligence

Reading the `description` field across many listings for the same role reveals how competitors position compensation, flexibility and culture. It is a direct window into how rivals are pitching themselves to the same candidate pool you are targeting.

#### 📧 Building Segmented Outreach Lists

Because `keyword` and `customDomains` jointly determine what lands in the dataset, you can build cleanly segmented lists in separate runs — one for consumer-domain individual contacts, another for a specific corporate domain — without any post-hoc sorting.

***

### ⚙️ Tips for Better Indeed Email Scraping Results

- **Use specific, targeted keywords.** Better results come from precise terms than from broad ones. `senior php developer` outperforms `developer` for relevance, even though it returns fewer rows.
- **Test with a low `maxEmails` first.** Run at five or ten to confirm your keyword and domain combination returns anything useful before committing to a large run. It is the cheapest debugging step available.
- **Add related terms rather than repeating runs.** The `keywords` array accepts many entries and tags each result with its source, so testing five variations in one run gives you comparative yield data for free.
- **Keep the domain list focused.** Every extra entry in `customDomains` multiplies the search space. Two or three well-chosen domains produce better throughput than ten speculative ones.
- **Extend the run timeout for large jobs.** Bigger keyword sets and higher email limits take longer. If you set `maxEmails` in the thousands, raise the timeout in **Run Options** — the default is 3600 seconds — so the run is not cut short.
- **Broaden before you conclude there is nothing there.** If results are thin, widen the keywords, drop the location filter, or add more domains before assuming the search space is empty.
- **Validate every address before sending.** Extraction reports what is published; it does not confirm deliverability. A syntax and MX check protects your sending reputation.

***

### 🛠️ Troubleshooting

**The run finished with very few emails — what went wrong?**
Usually the search was too narrow. A tight `location` combined with a niche keyword and a single email domain can legitimately return almost nothing. Widen one constraint at a time: first drop the location, then add related keywords, then add domains.

**The run hit the timeout before reaching `maxEmails`.**
Larger searches take longer, and the default run timeout is 3600 seconds. Increase the timeout in **Run Options**, or lower `maxEmails` and run several smaller jobs instead. Addresses already found are retained in the dataset either way.

**I am seeing the same email more than once across runs.**
Duplicate suppression operates within a single run. Across separate runs the same address can reappear, particularly with overlapping keywords. Deduplicate on `email` at the point where you merge datasets.

**Some rows have a generic or truncated title.**
The `title` and `description` fields come from what is present on the source result. Where a listing exposes little text, those fields fall back to a placeholder. The `url` field is always the reliable way to see the full listing.

**Extracted addresses bounce when I email them.**
The scraper reports addresses as published, with no deliverability verification. Some will be stale, some will be role addresses that no longer route. Always run a verification pass before a campaign.

***

### ❓ Frequently Asked Questions About Indeed Email Scraping

**What does the Indeed Email Scraper do?**
It is an Indeed email scraper that searches publicly indexed listings using keywords you supply, extracts email addresses at the domains you specify, and returns each address together with the listing title, description, source URL and the keyword that found it.

**What do I need to provide to run it?**
Only `keywords` is required. Everything else — `location`, `customDomains` and `maxEmails` — has sensible defaults, so a minimal run is a single keyword and nothing more.

**How do I control how many emails I get?**
Use `maxEmails`. It accepts values from 1 to 10000 and defaults to 20. The scraper stops as soon as the limit is reached, which is what keeps run time and cost predictable.

**Can I restrict results to particular email domains?**
Yes, that is what `customDomains` is for. The defaults target `@gmail.com` and `@yahoo.com`, and you can replace them with any domains relevant to your search, including specific corporate domains.

**Does the location filter work for any country?**
The `location` field is a free-text string passed into the search, so it accepts cities, regions and countries. Narrow locations reduce the result pool considerably, so pair them with broader keywords.

**Will I definitely get the number of emails I set in `maxEmails`?**
No. It is a ceiling, not a target. Setting a higher limit allows for more potential results but does not guarantee reaching that number — the actual yield depends on how many matching addresses exist in the public search space.

**Which keyword produced each email?**
The `keyword` field on every row records the exact input term that surfaced it, which lets you measure yield per keyword and refine future runs accordingly.

**Are the extracted email addresses verified?**
No. The scraper reports addresses as they are published. It performs no MX lookup or SMTP probe, so run your own validation before adding anything to an outreach sequence.

**Do I need proxies or an Indeed account?**
Neither. Proxy rotation is handled automatically by the Actor, and no login, cookies or platform credentials are required.

**Does the scraper use a headless browser?**
No. It uses asynchronous HTTP requests with HTML parsing, which is why it runs quickly and cheaply compared with browser-based extraction tools.

**What happens if I abort a run partway through?**
Every address is pushed to the dataset as it is found, so results collected before the abort are retained. The scraper also persists its progress cursor across keywords and domains.

**Can I run this on a schedule?**
Yes. Apify's scheduler supports any cron expression, which suits recruitment workflows where you want a daily or weekly feed of newly published opportunities.

**What export formats are available?**
JSON, CSV, XLSX, XML, RSS and HTML from the dataset UI, plus programmatic retrieval through the Apify dataset API.

**How should I handle personal email addresses responsibly?**
Treat them as personal data. Establish a lawful basis before contacting anyone, identify yourself clearly, include an opt-out in every message, honour suppression requests immediately and keep retention periods short.

**Can I request custom features for this scraper?**
Yes. Custom filters, additional output fields and tailored delivery pipelines can be built — get in touch at scraperhubapi@gmail.com with your requirements.

***

### 🆘 Support & Feedback

If something is not working as expected, please open a ticket on the **Issues** tab of this Actor and include the run ID along with the input you used. Issues raised there are tracked and addressed fastest.

For custom features or tailored solutions — additional filters, different output fields, verification built into the pipeline, or delivery straight into your ATS or CRM — reach out at **scraperhubapi@gmail.com**.

If the Indeed Email Scraper helps your recruitment or prospecting workflow, please leave a review on the Actor page. Ratings and written feedback directly influence what gets built next.

***

### ⚖️ Disclaimer

This Indeed email scraper collects only publicly accessible information from publicly indexed pages. It does not log in to any account, bypass authentication, defeat access controls, or retrieve anything that is not visible to an ordinary visitor.

You are responsible for how you use the extracted data. Email addresses and listing details frequently constitute personal data, so if you process them under the GDPR, the UK GDPR, the CCPA, PECR, CAN-SPAM or comparable legislation, you must establish a lawful basis for contact, identify yourself clearly in every message, provide a working opt-out, honour suppression requests without delay, and apply proportionate retention and security controls. Unsolicited bulk email may be unlawful in a recipient's jurisdiction even when the address itself was publicly published.

Respect the terms of service of Indeed and of any search service involved, and comply with all applicable employment, recruitment-advertising and data-protection laws in your jurisdiction. An address appearing in these results means it was published publicly, not that its owner consented to receive marketing.

If you believe your personal data has been collected through this Actor and you would like it removed, contact **scraperhubapi@gmail.com** and we will action the request.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

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

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# Actor output Schema

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

Records scraped by Indeed Email Scraper Fast Advanced And Cheapest, stored in the run's default dataset.

# 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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/indeed-email-scraper-fast-advanced-and-cheapest"
        }
    }
}

```

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/Sq0ktjmnVWJHATBXr/builds/uSB1suOm28aGQdQqX/openapi.json