# Tech Stack Detector: CMS, Analytics, Hosting & Email Provider (`wisekit/tech-stack-detector`) Actor

Find the CMS, ecommerce platform, analytics, frameworks, CDN, hosting and email provider behind any website. Reads robots.txt, the homepage and optionally DNS MX records. $2 per 1,000 sites analysed; blocked and unreachable sites are free. Free demo. No personal data.

- **URL**: https://apify.com/wisekit/tech-stack-detector.md
- **Developed by:** [Wisekit](https://apify.com/wisekit) (community)
- **Categories:** Developer tools, SEO tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 site analyseds

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

## Tech Stack Detector: CMS, Analytics, Hosting & Email Provider

Find out what any website is built with: the CMS, ecommerce platform, analytics and tag managers, JavaScript and web frameworks, CDN, hosting, web server, payment and marketing tools, with versions where the site shows them. **$2 per 1,000 sites analysed** ($0.002 each). No start fee, and sites that can't be read or show no known technology are free.
Want to see the output first? Turn on **Free demo** in Options: five fictional sample rows, nothing requested, no charge.

> **What it reads.** For each site it reads `robots.txt` and the homepage, once, and nothing else. It never logs in, fills forms, runs a browser or uses proxies, and it returns technology names only: no page text, no cookie values, no email addresses, phone numbers or names. Technology names are trademarks of their owners; this Actor is not affiliated with any of them.

### What does Website Tech Stack Detector do?

You give it a list of websites. For each one you get one tidy row:

- **The main platform at a glance.** `cms` (WordPress, Drupal, Webflow...) and `ecommercePlatform` (Shopify, WooCommerce, Magento...) as single values you can filter on.
- **Grouped lists.** `frameworks`, `analytics`, `tagManagers`, `cdn`, `hosting`, `webServers`, `programmingLanguages`, `paymentProcessors` and `marketingAutomation`, each a plain list of names.
- **Every technology detected.** `technologies` holds each one with its categories, the version when the page reveals it, and a confidence from 0 to 100; `technologyNames` is the same as a simple list ("WordPress 6.8", "jQuery 3.7.1").
- **Honest failures.** Sites that block automated requests, disallow us in robots.txt, don't resolve or time out come back with a clear `status` and `message`, **free**.

Results land in two tables: **Tech stacks** (one line per site with the main groups) and **All technologies** (every technology with versions and details), plus a `SUMMARY` record with the most common technologies in your list and a `PROBLEMS` record listing the sites that gave no result.

### Who uses it

- **Agencies and freelancers** qualifying prospects: which shops run WooCommerce, which sites still use an old jQuery, who has no analytics or tag manager.
- **SaaS sales and growth teams** building lead lists by technology: every site in a list that uses Shopify and Klaviyo, or HubSpot, or a competitor's widget.
- **Market researchers** counting platform share across hundreds of sites in a niche.
- **Developers and IT teams** checking what their own portfolio of sites runs on before a migration or security review.
- **AI agents and automations** that need structured "what is this site built with" facts through the API or MCP.

### How to detect a website's tech stack

1. Paste websites into **Websites**, one per line. Bare domains (`example.com`) or full URLs both work; only the homepage is read, and `www.` duplicates are merged.
2. Optional: set **Max sites to analyse** to cap how many sites (and so how much money) one run can use.
3. Click **Start**. The two prefilled sites finish in a few seconds.
4. Open the **Tech stacks** view, filter on `cms` or `ecommercePlatform`, or export everything as CSV, Excel or JSON.

New here? Turn on **Free demo** first. It shows five fictional rows (a WordPress shop, a Shopify store, a Next.js app, a site whose robots.txt disallows us and a site that blocks us) so you can see the columns before you spend anything.

### Input

| Field | Default | Notes |
|---|---|---|
| `urls` | (required) | Websites, one per line: domains or URLs. Up to 1000 per run (10 on the Apify free plan). Only the homepage is read; IP addresses and internal names are not read. |
| `maxUrls` | `1000` | The most sites this run reads. Sites beyond it come back as `skipped_max_urls`, free. No extra cost. |
| `includeEmailProvider` | `false` | Also name the email provider (Google Workspace, Microsoft 365, Zoho Mail ...) and any email security gateway (Mimecast, Proofpoint ...) from one DNS lookup of the domain's MX records. No extra cost. |
| `demo` | `false` | Five fictional sample rows, no requests, no charge. |
| `maxConcurrency` | `10` | 1 to 20 sites read at the same time. No extra cost. |

Example input: `{"urls": ["apify.com", "example.com"]}`

### What data do you get?

#### Sample output (from the free demo, fictional sites)

| url | status | cms | ecommercePlatform | frameworks | analytics | cdn | hosting |
|---|---|---|---|---|---|---|---|
| https://bakery.example/ | `ok` | WordPress | WooCommerce | | Google Analytics | Cloudflare | |
| https://fashion.example/ | `ok` | | Shopify | | Facebook Pixel, Google Analytics | Cloudflare | |
| https://saas.example/ | `ok` | | | Next.js, React | | | Vercel |
| https://private.example/ | `robots_disallowed` | | | | | | |
| https://protected.example/ | `blocked` | | | | | | |

One full row (shortened) looks like this:

```json
{
  "url": "https://bakery.example/",
  "domain": "bakery.example",
  "finalUrl": "https://www.bakery.example/",
  "status": "ok",
  "httpStatus": 200,
  "summary": "Demo (fictional data): 10 technologies: CMS WordPress; ecommerce WooCommerce; analytics Google Analytics; CDN Cloudflare.",
  "technologyCount": 10,
  "technologyNames": ["WordPress 6.8", "WooCommerce 9.4", "Elementor 3.25", "PHP", "MySQL", "Google Analytics", "Google Tag Manager", "Cloudflare", "Stripe", "jQuery 3.7.1"],
  "cms": "WordPress",
  "ecommercePlatform": "WooCommerce",
  "frameworks": [],
  "analytics": ["Google Analytics"],
  "tagManagers": ["Google Tag Manager"],
  "cdn": ["Cloudflare"],
  "hosting": [],
  "paymentProcessors": ["Stripe"],
  "technologies": [
    { "name": "WordPress", "categories": ["CMS", "Blogs"], "version": "6.8", "confidence": 100 },
    { "name": "WooCommerce", "categories": ["Ecommerce", "WordPress plugins"], "version": "9.4", "confidence": 100 }
  ],
  "retryable": false,
  "demo": true
}
```

#### Fields

| Field | What it is |
|---|---|
| `url`, `domain`, `finalUrl` | The homepage address read first, the host you entered, and the page actually analysed after redirects |
| `status`, `statusLabel`, `summary`, `message` | `ok`, or why the site wasn't analysed, in a code, plain words and a one-line summary |
| `httpStatus` | The homepage's HTTP status code, when one was received |
| `cms`, `ecommercePlatform` | The content management system and ecommerce platform detected (the most certain one if several) |
| `frameworks`, `analytics`, `tagManagers`, `cdn`, `hosting`, `webServers`, `programmingLanguages`, `paymentProcessors`, `marketingAutomation` | Lists of technology names in each group |
| `technologyCount`, `technologyNames` | How many technologies were detected, and their names with versions |
| `technologies` | Every technology: `name`, `categories`, `version` (null when not visible) and `confidence` (0 to 100) |
| `emailProvider`, `emailSecurityGateway`, `mxHosts` | Only with `includeEmailProvider` on: who hosts the domain's email (for example Google Workspace or Microsoft 365, or `Other / self-hosted`, `No MX record`), a security gateway in front of it if any, and up to 5 mail-server host names. Never an email address |
| `retryable` | `true` when running the site again later may give a result |
| `inputs`, `checkedAt`, `demo` | What you typed for this site, when it was read, and `true` only on demo rows |

### How it detects technologies

It compares what the homepage reveals with the fingerprints of the open-source **webappanalyzer** project (licensed GPL-3.0; the licence and notice ship with this Actor). The data covers about 7,700 technologies; about 6,600 of them can be recognised without a full browser, and those are the ones this Actor looks for. It checks:

- response headers (for example `server`, `x-powered-by`, `x-shopify-stage`);
- the **names** of cookies the site sets (never their values);
- `<meta>` tags such as `generator`;
- the addresses of scripts and stylesheets, and inline script code;
- patterns in the HTML and CSS selectors on the page;
- the HTTPS certificate issuer and robots.txt.

With `includeEmailProvider` on, it also makes one DNS query for the domain's mail servers (MX records) and matches their host names against Wisekit's own list of about 25 email providers and security gateways. Nothing is sent to the mail servers or the website for this.

What it can't see: technologies that only show up when JavaScript runs in a browser, on pages other than the homepage, or only for logged-in visitors. A site behind a firewall that blocks automated requests can't be analysed at all (that row is free). Some sites hide or fake their headers. Treat the result as what the homepage publicly shows, not a full audit; `confidence` below 100 means only a weaker sign was found.

### How much does it cost to detect a website's tech stack?

**$0.002 per site analysed** (pay per event `site-analysed`), charged only when the homepage was read and at least one technology was detected (status `ok`).

No start fee. Free: `nothing_detected`, `robots_disallowed`, `robots_unavailable`, `skipped_crawl_delay`, `blocked`, `rate_limited`, `http_error`, `not_html`, `unreachable`, `blocked_address`, `time_limit`, `error`, `invalid_input` and the `skipped_*` statuses, and the demo. Your maximum charge per run is respected, counting sites still being read, and `maxUrls` caps a run in sites instead of dollars.

**Example 1: qualify 500 prospect sites.** 460 are read and show technologies; 25 block automated requests, 10 don't resolve and 5 disallow us in robots.txt. You pay 460 × $0.002 = **$0.92**; the 40 other rows are free.

**Example 2: monthly check of 50 client sites.** All 50 are read: 50 × $0.002 = **$0.10** per run, about $1.20 a year.

**Apify free plan:** up to 10 sites per run; the rest come back as `skipped_plan_limit`, free.

#### What the price buys

You can find free browser extensions and Store Actors that charge a little less per site. For its price, this one gives you: no start fee and no charge for blocked, failed, empty or skipped sites; flat, typed columns (`cms`, `ecommercePlatform`, `analytics`...) ready for a spreadsheet filter; versions and confidence per technology; a free demo; and a `maxUrls` cap so you know the most a run can cost before you start. It reads each site politely (one request at a time, robots.txt obeyed), which keeps its own footprint small.

### Use it from an AI agent or the API

Minimal input: `{"urls": ["example.com"]}`. Every row has a one-line `summary` an agent can read directly.

Python (`pip install apify-client`, replace `<YOUR_API_TOKEN>`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("wisekit/tech-stack-detector").call(run_input={"urls": ["apify.com", "example.com"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["url"], row["status"], row["cms"], row["ecommercePlatform"], row["technologyNames"])
```

MCP (Claude, Cursor and other MCP clients): add Apify's MCP server with this Actor as a tool.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=wisekit/tech-stack-detector",
      "headers": { "Authorization": "Bearer <YOUR_API_TOKEN>" }
    }
  }
}
```

Example prompts: "What CMS and analytics do these 20 competitor sites use?" and "Which of these shops run Shopify, and which run WooCommerce?"

### Use it in n8n

1. Add an **HTTP Request** node. Method `POST`, URL `https://api.apify.com/v2/acts/wisekit~tech-stack-detector/run-sync-get-dataset-items`.
2. **Authentication:** Generic credential type → Header Auth, with name `Authorization` and value `Bearer <your Apify API token>`.
3. **Body:** JSON, for example:

```json
{
  "urls": ["example.com", "example.org"],
  "includeEmailProvider": true
}
```

4. Each result row comes back as one n8n item, ready for Slack, Google Sheets, a database or an IF node. Use it to enrich new leads from a CRM or a sheet: pass their websites in `urls` and write the CMS, analytics and hosting back to each row. Free demo input: `{"urls": ["example.com"], "demo": true}`.

The call waits for the run to finish, for up to 5 minutes. For longer runs, start the run with `POST https://api.apify.com/v2/acts/wisekit~tech-stack-detector/runs` and read the dataset when it finishes, or use n8n's Apify node. To try the flow without spending anything, send the free demo input first.

### Check a list on a schedule

1. Run the Actor once with your list, then choose **Save as a new task**.
2. In Apify Console go to **Schedules**, create a schedule (for example on the 1st of each month, cron `0 6 1 * *`) and add the task.
3. Add an integration to the task (email, Slack, Google Sheets, Zapier, Make or a webhook) to get each finished dataset, and compare `technologyNames` with last month's to spot platform changes.

### How it treats the websites

- Reads `robots.txt` first and obeys it for our User-Agent and for `*`. If robots.txt disallows the homepage, the homepage is not requested (`robots_disallowed`, free). If robots.txt can't be read because of a server error, the site is skipped to be safe (`robots_unavailable`, free). A Crawl-delay up to 10 seconds is honoured; longer ones are skipped. A missing robots.txt (HTTP 4xx) or one that returns a web page instead of rules means no rules apply, as the robots.txt standard (RFC 9309) says; one that returns a bot-challenge page stops the site as `blocked`, free.
- One request at a time per site, at least 1 second apart: usually 2 requests (robots.txt and the homepage), or 4 when the homepage redirects to another host such as `www.` (that host's robots.txt is read and obeyed first). At most 5 redirects are followed. Each site has a 20-second time limit.
- An HTTP 403, 401 or 451 answer or a bot-challenge page stops at once (`blocked`, free); no retries, no workarounds. HTTP 429 gets at most one short wait if the site asks for 5 seconds or less, otherwise `rate_limited`, free.
- No proxies, no IP rotation, no browser, no logins, no forms, no cookies sent. Every request carries an honest User-Agent, `WisekitTechStackDetector/1.0`, that names this Actor.
- Only public websites: IP addresses, internal names and any domain that resolves to a private or internal network address are refused, also after every redirect (`blocked_address`, free).

### What it never does

- No personal data: no page text, no email addresses, phone numbers or names, no cookie values and no header values are stored or returned. Only technology names, categories, versions and confidence leave the page.
- No technology logos or icons.
- Your results stay in your own Apify dataset. We keep no copy and share nothing between users; the run log shows counts and statuses only.

### Status values

`ok`, `nothing_detected`, `robots_disallowed`, `robots_unavailable`, `skipped_crawl_delay`, `blocked`, `rate_limited`, `http_error`, `not_html`, `unreachable`, `blocked_address`, `time_limit`, `error`, `invalid_input`, `skipped_max_charge`, `skipped_plan_limit`, `skipped_run_limit`, `skipped_max_urls`. Only `ok` is charged.

### FAQ

**Is it legal to use?** It reads only what any visitor's browser receives from a site's public homepage, obeys robots.txt, identifies itself honestly, stops when a site refuses, and returns no personal data. How you use the results is up to you; checking your own sites, market research and qualifying businesses are typical uses. Respect the sites' terms and anti-spam laws when you contact anyone. This is not legal advice; if you are unsure about your use, ask a lawyer.

**Why is a technology I know the site uses missing?** It may only appear when JavaScript runs in a browser, only on inner pages, or only for logged-in users; or the site hides it. This Actor reads the homepage's HTML and headers only.

**Why was a site `blocked`?** Its firewall or bot protection refused automated requests. We don't try to get around that. The row is free.

**What does `confidence` mean?** 100 means a clear sign was found; lower values come from weaker signs in the fingerprint data (for example a generic header). Filter on `confidence` if you only want certain results.

**Can it read pages other than the homepage?** No. One page per site keeps it fast, cheap and polite. Any path you enter is dropped.

**How fast is it?** Measured 17 Nov 2026 on 22 sites (3 runs): about 2 to 4 seconds each (robots.txt, a 1-second pause, the homepage). 10 sites are read in parallel by default, so 1,000 sites is an estimate of 5 to 10 minutes. If a run is about to hit its time limit, the sites not yet started are listed as `skipped_run_limit` (free) so you can run them again.

**What if I'm on the Apify free plan?** Free-plan runs analyse up to 10 sites; the rest come back as `skipped_plan_limit`, free.

### Other Wisekit Actors

- [AI Visibility Tracker: ChatGPT, Perplexity, Gemini & Claude](https://apify.com/wisekit/ai-search-visibility-tracker): see whether AI assistants recommend a brand or its competitors.
- [Greenhouse, Lever, Ashby & Workable Jobs API: New Jobs Feed](https://apify.com/wisekit/ats-job-feed): open jobs from employers' own job boards in one set of fields, with new and closed jobs since the last run.
- [Shopify Price & Stock Monitor: Competitor Change Alerts](https://apify.com/wisekit/product-price-monitor): competitors' prices, stock, and new and removed products since your last run.
- [Shopify Store Lead Qualifier: Country, Prices & Emails](https://apify.com/wisekit/store-qualifier): Shopify or not, country, catalogue size, price band and generic public contact emails for a list of store domains.
- [Domain Availability & Expiry Checker: Bulk RDAP Lookup](https://apify.com/wisekit/domain-lookup): registration status, expiry date, registrar and DNS for a list of domains.
- [Company Contact Page & Social Links Finder](https://apify.com/wisekit/contact-finder): a company's contact page and social profile links from its website.
- [Website Screenshot & PDF: Full Page, Mobile, Dark Mode](https://apify.com/wisekit/website-screenshot): full-page, mobile or dark-mode screenshots and PDFs of web pages.

### Feedback and support

Found a wrong detection, a missing technology or need a field? Open an issue on the Actor's **Issues** tab. We read every issue and aim to reply within 24 hours. Include the site and the run ID if you can.

### Changelog

- **0.3 (18 Nov 2026)**: optional email provider (`includeEmailProvider`): `emailProvider`, `emailSecurityGateway` and `mxHosts` from the domain's MX records. Same price.
- **0.2 (17 Nov 2026)**: a bot-challenge page served instead of robots.txt stops the site as `blocked` (free); sites not started before the run's time limit are listed as free `skipped_run_limit` rows; `finalUrl` drops query strings; email addresses inside an input are never echoed; no plain-HTTP retry after the HTTPS connection is dropped; demo uses `.example` addresses.
- **0.1 (build 0.1.2, 17 Nov 2026)**: "most common" in the status message leaves out generic items (HSTS, Open Graph, HTTP/3, certificate authorities).
- **0.1 (17 Nov 2026)**: first version: robots.txt and homepage read, about 6,600 browser-free fingerprints, grouped columns, versions and confidence, free demo, `maxUrls` cap.

# Actor input Schema

## `urls` (type: `array`):

Required. Websites to analyse, one per line: a bare domain ("example.com") or any URL. Only the site's homepage is read, so "https://www.example.com/blog/post" is analysed as https://www.example.com/. Up to 1000 per run (10 on the Apify free plan). Duplicates (with or without www.) are merged. IP addresses and internal names are not read. Agent example: {"urls":\["apify.com","example.com"]}.

## `maxUrls` (type: `integer`):

The most sites this run reads (1 to 1000). Sites beyond it come back as skipped_max_urls and are free, so this also caps the cost: at most $0.002 per site. No extra cost. Example: 100. Default 1000.

## `includeEmailProvider` (type: `boolean`):

Adds emailProvider (for example Google Workspace, Microsoft 365, Zoho Mail), emailSecurityGateway (for example Mimecast, Proofpoint) and mxHosts, from one DNS lookup of the domain's mail servers (MX records). No extra request to the website and no email address is read. Filled on analysed sites only. No extra cost. Example: true. Default off.

## `demo` (type: `boolean`):

Shows five fictional sample rows (a WordPress shop, a Shopify store, a Next.js app, a site whose robots.txt disallows us, a site that blocks us). Nothing is requested and nothing is charged; the websites you entered are ignored. Example: true. Default off.

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

How many different sites are read at the same time (1 to 20). No extra cost. Each site still gets one request at a time, at least 1 second apart. Example: 10. Default 10.

## Actor input object example

```json
{
  "urls": [
    "apify.com",
    "example.com"
  ],
  "maxUrls": 1000,
  "includeEmailProvider": false,
  "demo": false,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per site: status, CMS, ecommerce platform, frameworks, analytics, CDN, hosting and a one-line summary.

## `technologies` (type: `string`):

One row per site with every technology detected: name, categories, version and confidence.

## `summary` (type: `string`):

Counts per status, the most common technologies in this run and the fingerprint data version.

## `problems` (type: `string`):

Only the sites that gave no result, with the reason and whether a later run may work. Free.

# 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 = {
    "urls": [
        "apify.com",
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wisekit/tech-stack-detector").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 = { "urls": [
        "apify.com",
        "example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("wisekit/tech-stack-detector").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 '{
  "urls": [
    "apify.com",
    "example.com"
  ]
}' |
apify call wisekit/tech-stack-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wisekit/tech-stack-detector"
        }
    }
}
```

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/sGSI8fT83VgCRDgon/builds/77oqWMPle79S0SdTC/openapi.json
