# Website Image Downloader Pro (`scrapers-hub/website-image-downloader-pro`) Actor

Website Image Downloader Pro extracts and saves every image from a page, including CSS background images, with retries and timeout control. 🖼️ For asset audits, competitor creative research and bulk image archiving.

- **URL**: https://apify.com/scrapers-hub/website-image-downloader-pro.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## Website Image Downloader Pro

### 🖼️ Website Image Downloader Pro – Bulk Image URL Extraction from Any Website

**Website Image Downloader Pro** scans any list of website URLs and extracts every image reference it can find on those pages, returning a clean dataset of image URLs, the source page each one came from, and a derived filename. It handles both standard `<img>` elements and CSS `background-image` declarations, which means it catches the hero banners, decorative panels and sprite backgrounds that simpler image scrapers silently miss.

The Actor is built for anyone who needs image assets at scale rather than one at a time: design teams archiving a site before a rebuild, e-commerce operators pulling product photography, SEO auditors checking image inventory, competitive researchers cataloguing creative, and machine-learning engineers assembling training sets. Point it at a URL list, run it, and you get a downloadable manifest of every image on those pages.

Requests are made through automatic proxy rotation with retry handling, so pages that respond with 403, 429 or transient server errors are retried with a fresh session rather than dropped. The result is a bulk image extraction tool that holds up on real sites, not just simple static pages.

***

### 📊 What Data Can You Extract with This Website Image Downloader?

Each dataset item represents one discovered image. The output is deliberately compact — three fields that answer the three questions that matter:

| Category | Fields | What you get |
|---|---|---|
| 🔗 Asset location | `image_url` | The absolute, directly fetchable URL of the image |
| 🌐 Source attribution | `input_url` | The website URL from your input that produced this image |
| 📄 File identity | `filename` | The filename derived from the image URL, ready for use when saving to disk |
| 🧩 Coverage | `image_url` (background images) | When `includeBackgroundImages` is enabled, CSS `background-image: url(...)` references appear in the same field alongside `<img>` sources |
| 📦 Batch context | `input_url` across items | Because every row carries its source page, a multi-URL run remains fully attributable after export |

The field doing the most work here is `input_url`. Because every image row records which of your input pages produced it, you can run a hundred URLs in a single job and still group, filter and audit results per site without any post-processing guesswork.

***

### 🌟 Key Features of the Website Image Downloader

| Feature | Description |
|---|---|
| 📋 Bulk URL input | Supply any number of website URLs in a single run through the `inputUrls` list; results from all of them land in one dataset |
| 🎨 CSS background image support | `includeBackgroundImages` (default `true`) also extracts URLs from `background-image: url(...)` in inline `style` attributes and `<style>` blocks |
| 🔁 Automatic retry with fresh sessions | `maxRetries` (default `5`) retries failed requests — 403, 429, 5xx and network errors — each attempt using a fresh proxy session and browser fingerprint |
| 🛡️ Automatic proxy rotation | Proxy handling is managed for you, so blocked or rate-limited requests are retried from a different address without any configuration |
| ⏱️ Configurable request timeout | `requestTimeoutSecs` (default `30`) caps how long each HTTP request may take, preventing a single slow page from stalling a run |
| 🔗 Absolute URL resolution | Relative image paths found in page markup are resolved into fully qualified, directly fetchable URLs |
| 📄 Filename extraction | The `filename` field is derived from the image URL, so you can save assets to disk without parsing paths yourself |
| ⚡ Browser-free extraction | The Actor parses HTML directly rather than rendering pages in headless Chrome, which keeps runs fast and memory-light |
| 🧾 Flat three-field schema | A minimal, consistent output shape that exports cleanly to CSV and imports into any downstream tool without reshaping |

***

### 🚀 Why Choose This Website Image Downloader?

**It finds the images other scrapers miss.** A large share of the visual weight on a modern site is delivered through CSS rather than `<img>` tags — full-bleed hero sections, section backgrounds, icon sprites. With `includeBackgroundImages` enabled by default, those references are extracted alongside standard image elements, giving you a genuinely complete inventory.

**Retries are built in, not bolted on.** The `maxRetries` setting defaults to 5, and each retry uses a fresh proxy session and browser fingerprint. That matters because the failure modes that actually kill image scrapes — a 429 rate limit, an intermittent 403 — are precisely the ones that succeed on a second attempt from a different address.

**Every row is traceable to its source.** The `input_url` field means a batch run of dozens of sites produces one dataset you can still reason about. Filter to a single site, count images per domain, or diff two runs of the same URL to see what changed.

**Minimal configuration, sensible defaults.** Only `inputUrls` is required. The three tuning parameters all ship with defaults chosen to work on typical sites, so your first run needs one field filled in and nothing else.

***

### 📥 Input

The website image downloader requires a list of URLs. The remaining fields tune retry behaviour, coverage and timeouts.

```json
{
  "inputUrls": [
    { "url": "https://www.apify.com/" }
  ],
  "maxRetries": 5,
  "includeBackgroundImages": true,
  "requestTimeoutSecs": 30
}
```

#### 🔧 Website Image Downloader Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `inputUrls` | array | ✅ Yes | `[{ "url": "https://www.apify.com/" }]` (prefill) | List of website URLs to scan for images |
| `maxRetries` | integer | No | `5` | How many times to retry a failed request (403/429/5xx/network errors) before giving up on a URL. Each retry uses a fresh proxy session and browser fingerprint |
| `includeBackgroundImages` | boolean | No | `true` | Also extract image URLs referenced via `background-image: url(...)` in inline style attributes and `<style>` blocks |
| `requestTimeoutSecs` | integer | No | `30` | Timeout for each HTTP request |

#### 💡 Input Examples

**Single page, defaults:**

```json
{
  "inputUrls": [
    { "url": "https://example.com/products" }
  ]
}
```

**Multiple pages, `<img>` tags only:**

```json
{
  "inputUrls": [
    { "url": "https://example.com/category/shoes" },
    { "url": "https://example.com/category/bags" },
    { "url": "https://example.com/category/watches" }
  ],
  "includeBackgroundImages": false
}
```

**Aggressive retries for a protected site:**

```json
{
  "inputUrls": [
    { "url": "https://example.com/gallery" }
  ],
  "maxRetries": 10,
  "requestTimeoutSecs": 60,
  "includeBackgroundImages": true
}
```

***

### 📤 Output

Each discovered image becomes one dataset item. Below is a real record from an actual run of Website Image Downloader Pro:

```json
{
  "image_url": "https://apify.com/og-image?title=Thousands+of+tools%0Afor+your+AI",
  "input_url": "https://www.apify.com/",
  "filename": "og-image"
}
```

#### 🧾 Website Image Downloader Output Fields

| Field | Type | Description |
|---|---|---|
| `image_url` | string | null | URL of the item's image |
| `input_url` | string | null | URL supplied in the Actor input that produced this item |
| `filename` | string | null | Name of the file |

The `filename` value is derived from the image URL path. As the real sample above shows, URLs that carry query parameters rather than a conventional file extension will produce a filename without an extension — in that case, infer the format from the `Content-Type` header when you download the asset.

***

### 💻 How to Use the Website Image Downloader (Step by Step)

#### Step 1: Open Website Image Downloader Pro on Apify

Sign in to your Apify account and open the Actor page, then click **Start** to open the input form. A free Apify account is enough to begin, and it gives you a console where every run, log and dataset is retained for later reference. The console is also where you will configure schedules, webhooks and API access once your workflow matures.

#### Step 2: Build your URL list

Add the pages you want scanned to `inputUrls`. The editor accepts URLs one per line or as a pasted list, and it also supports uploading a file of URLs, which is the practical route when you have hundreds. Be specific about which pages you target: pointing at a category listing page returns thumbnails, while pointing at individual product pages returns the full-resolution gallery images. Choosing the right page type is the single biggest factor in the quality of your results.

#### Step 3: Decide on CSS background image coverage

`includeBackgroundImages` is enabled by default and will extract URLs from `background-image: url(...)` declarations in inline styles and `<style>` blocks in addition to `<img>` elements. Keep it on when you want a complete visual inventory of a page. Turn it off when you specifically want content images only — for example when building a product photography set, where decorative background textures would be noise.

#### Step 4: Tune retries and timeout for the target site

`maxRetries` defaults to 5 and `requestTimeoutSecs` to 30. These work for most sites. If you are targeting a domain known for aggressive rate limiting, raise `maxRetries` so the Actor persists through 429 responses with fresh proxy sessions. If pages are heavy or slow to respond, raise `requestTimeoutSecs`. Raising both increases run duration, so change them deliberately rather than by default.

#### Step 5: Run the Actor and monitor the log

Start the run. The log streams live, reporting each URL as it is fetched and how many images were found. Watch for repeated retry messages against a particular domain — that is your signal that the site is pushing back and that a higher `maxRetries` or a smaller URL batch may be appropriate. Because the Actor does not launch a browser, runs are generally quick even across many pages.

#### Step 6: Review and filter the dataset

Open the **Output** tab when the run finishes. Each row shows `image_url`, `input_url` and `filename`. Before downloading anything, scan the list for obvious noise: tracking pixels, tiny spacer graphics, or repeated logo files appearing on every page. Filtering these out in the dataset view or after export saves bandwidth and keeps your asset library clean.

#### Step 7: Export the manifest and download the assets

Export to CSV or JSON from the dataset view. The exported file is a manifest, not the images themselves — the actual download step is yours, using the `image_url` values. A short script with `wget`, `curl` or Python's `requests` iterating over the manifest, saving each asset under its `filename` and grouping by `input_url`, turns the dataset into an organised local image archive in a few lines.

***

### 🔌 API Access & Integrations

Run the website image downloader through the Apify API and get the dataset back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~website-image-downloader-pro/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "inputUrls": [
      { "url": "https://www.apify.com/" }
    ],
    "maxRetries": 5,
    "includeBackgroundImages": true,
    "requestTimeoutSecs": 30
  }'
```

The same with the official Python client, including a download loop:

```python
import requests
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "inputUrls": [{"url": "https://www.apify.com/"}],
    "includeBackgroundImages": True,
    "maxRetries": 5,
}

run = client.actor("scrapers-hub/website-image-downloader-pro").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["input_url"], "->", item["image_url"])
    # Optional: download the asset
    # data = requests.get(item["image_url"], timeout=30).content
    # open(item["filename"], "wb").write(data)
```

The Actor also plugs into Zapier, Make, Google Sheets, Slack, Airtable and any custom endpoint through Apify webhooks, so a completed image inventory can be pushed straight into your asset pipeline.

***

### 💡 Best Use Cases for Website Image Data

#### 🛒 E-commerce Product Photography Collection

Feed a list of product page URLs into `inputUrls` and the run returns every product photo with its source page recorded in `input_url`. This is the standard workflow for catalogue migration, marketplace listing preparation and supplier asset collection, because the `input_url` grouping keeps each product's images together without any manual sorting.

#### 🎨 Design Archives and Site Rebuild Audits

Before rebuilding a website, agencies need an inventory of every asset currently in use. Running the downloader across the full sitemap with `includeBackgroundImages` enabled captures both content images and the CSS-delivered backgrounds that would otherwise be forgotten until they break. The `filename` field makes reconstructing the asset directory straightforward.

#### 🔍 SEO and Accessibility Image Audits

An image inventory per page is the starting point for a technical SEO audit. Counting rows grouped by `input_url` immediately shows pages carrying unusually heavy image loads, while inspecting `image_url` patterns reveals whether a site is serving optimised formats or shipping unprocessed originals.

#### 🤖 Machine Learning Dataset Assembly

Computer vision projects need volume. Supplying a broad list of pages in `inputUrls` and exporting the `image_url` column produces a download manifest for a training set in minutes. Retaining `input_url` alongside each image preserves provenance, which matters for dataset documentation and for filtering by source later.

#### 🕵️ Competitive Creative Research

Marketing teams track how competitors present products visually. Running the downloader against a rival's category and landing pages produces a dated snapshot of their creative. Repeating the run periodically and comparing `image_url` sets reveals exactly when campaign imagery changed and what replaced it.

#### 📰 Content and Media Monitoring

Publishers and researchers collecting visual material around a topic can point the Actor at article URLs and pull the accompanying imagery in bulk. The `input_url` field keeps each image tied to the article it illustrated, which is essential when the images will later be cited or attributed.

#### 🗂️ Digital Asset Management Migration

When moving from one DAM or CMS to another, the first task is enumerating what exists. A run across the live site produces a complete manifest of `image_url` and `filename` pairs that can be used to script the bulk transfer, with `input_url` providing the page-level context needed to rebuild associations in the new system.

***

### ⚙️ Tips for Better Website Image Scraping Results

- **Target detail pages, not just listing pages.** Category pages usually serve small thumbnails. If you need full-resolution assets, supply the individual item or article URLs.
- **Raise `maxRetries` for protected domains.** Sites that return 429 or 403 under load are exactly the case retries were designed for — each attempt uses a fresh proxy session, so persistence often succeeds where a single request fails.
- **Turn off `includeBackgroundImages` when you want content images only.** Background extraction is valuable for complete inventories but adds decorative textures and gradients you may not want in a product asset set.
- **Increase `requestTimeoutSecs` for heavy pages.** Long, asset-dense pages can exceed the 30-second default. A timeout that is too short shows up as retried and eventually skipped URLs in the log.
- **Batch large URL lists into several runs.** Splitting a few thousand URLs across multiple runs makes failures easier to isolate and lets you adjust settings between batches rather than discovering a problem at the end.
- **Deduplicate on `image_url` after export.** Site-wide assets such as logos and icons appear on every page. A single deduplication pass dramatically shrinks the download set without losing anything unique.

***

### 🛠️ Troubleshooting

**The run returned no images for a URL. Why?**
The most common cause is a page that builds its gallery in JavaScript after load — the Actor parses the delivered HTML rather than rendering the page, so client-side-injected images are not present in the markup. Check the log for retry or error messages against that URL, and confirm the page shows images when JavaScript is disabled in your browser.

**Some `filename` values have no file extension.**
`filename` is derived from the image URL path. URLs that serve images through a query string — as in the real sample, `og-image?title=...` — have no extension in the path. Read the `Content-Type` header when downloading to determine the actual format.

**I am getting repeated 403 or 429 messages in the log.**
The target site is rate-limiting or blocking. Increase `maxRetries` so more fresh proxy sessions are attempted, and reduce the number of URLs from that same domain in a single run so requests are spread out.

**Why do I see the same logo image dozens of times?**
Site furniture — logos, icons, social badges — appears in the markup of every page you scan, so it is legitimately extracted once per page. Deduplicate on `image_url` after export to collapse these.

**Does the Actor download the actual image files?**
No. It produces a manifest of `image_url`, `input_url` and `filename`. Downloading the binary assets is a separate step you control, which keeps runs fast and lets you filter before spending bandwidth.

***

### ❓ Frequently Asked Questions About Website Image Downloading

**What does Website Image Downloader Pro actually do?**
It scans the website URLs you supply, extracts every image reference found in the page markup — including CSS background images — and outputs a dataset of image URLs, source page URLs and derived filenames.

**How many URLs can I scan in one run?**
There is no fixed limit in the input schema; `inputUrls` is an array. In practice, splitting very large lists across several runs makes monitoring and troubleshooting far easier.

**Does the website image downloader capture CSS background images?**
Yes. `includeBackgroundImages` is `true` by default and extracts URLs from `background-image: url(...)` declarations in inline `style` attributes and `<style>` blocks.

**Are relative image paths converted to full URLs?**
Yes. Image references found in markup are resolved to absolute, directly fetchable URLs in the `image_url` field.

**Can I configure my own proxy?**
No proxy setting is exposed in the input. Proxy rotation is handled automatically, and each retry uses a fresh proxy session and browser fingerprint.

**What happens when a page fails to load?**
The request is retried up to `maxRetries` times — five by default — with a fresh session each attempt. Failures on 403, 429, 5xx and network errors all trigger the retry path. If every attempt fails, the URL is skipped and the error is recorded in the run log.

**Does it work on JavaScript-heavy single-page applications?**
The Actor parses delivered HTML rather than rendering pages in a browser, so images injected purely by client-side JavaScript after load may not be captured. Images present in the initial HTML, including those in inline styles, are extracted normally.

**How do I actually download the images?**
Export the dataset, then iterate over the `image_url` column with a script — `wget`, `curl`, or Python `requests` — saving each file under its `filename`. The Python example above shows the pattern.

**Can I filter by image size or format?**
Not within the Actor; the output is a URL manifest without dimensions or file size. Filter by inspecting the URL pattern, or check headers during your download step.

**Why is `input_url` useful if I only scanned one page?**
For single-page runs it is redundant, but it becomes essential in batch runs — it is what lets you group hundreds of image rows back to the specific page each came from.

**Does the Actor use a headless browser?**
No. It performs HTTP requests and parses HTML directly, which keeps runs faster and lighter than browser-based image scrapers.

**Can I schedule recurring image scans?**
Yes. Use the Apify console's Schedules feature to rerun the same URL list periodically, then diff successive `image_url` sets to detect creative changes on the target site.

**What export formats are available?**
JSON, CSV, Excel, XML, HTML table and RSS, from the dataset view or through the Apify API.

**Will it capture images from behind a login?**
No. The website image downloader accesses publicly reachable pages only. Content requiring authentication is out of scope.

**Is it legal to download images from a website?**
The Actor collects publicly accessible image URLs. Images themselves are typically protected by copyright, and collecting a URL is not the same as acquiring a licence to reuse the asset. Ensure your intended use complies with the rights holder's terms.

***

### 🆘 Support & Feedback

If a site returns unexpected results, a run errors out, or a field is not populated as documented, please open a report in the **Issues** tab on the Actor page so it can be investigated.

Need a custom variant — image dimension capture, format filtering, direct upload to your storage bucket, or a bespoke scraper for a different target — email **scraperhubapi@gmail.com** with your requirements.

If Website Image Downloader Pro saves you time, a review on the Apify Store is genuinely appreciated and helps other users find it.

***

### ⚖️ Disclaimer

Website Image Downloader Pro extracts image URLs from publicly accessible web pages only. It does not access content behind authentication, bypass paywalls, or circumvent technical access controls.

You are responsible for how you use the output of this website image downloader. Images published on the web are, in almost all cases, protected by copyright and remain the property of their creators or licensors. Collecting an image URL does not grant you any right to reproduce, redistribute, modify or commercially exploit the underlying asset. Before using downloaded imagery, confirm you have the necessary licence or that your use falls within a recognised exception in your jurisdiction.

Where extracted images depict identifiable individuals, the resulting data may constitute personal data under GDPR, CCPA and equivalent privacy regimes. In those cases you must establish a lawful basis for processing, limit retention to what is necessary, and honour data subject rights.

You are also responsible for respecting the terms of service and `robots.txt` directives of the websites you scan, and for scanning at a rate that does not place an unreasonable burden on the target server.

If you believe images or data collected by this Actor relate to you and you would like them removed, contact **scraperhubapi@gmail.com** and the request will be handled promptly.

# Actor input Schema

## `inputUrls` (type: `array`):

List of website URLs to scan for images.

## `maxRetries` (type: `integer`):

How many times to retry a failed request (403/429/5xx/network errors) before giving up on a URL. Each retry uses a fresh proxy session and browser fingerprint.

## `includeBackgroundImages` (type: `boolean`):

Also extract image URLs referenced via background-image: url(...) in inline style attributes and <style> blocks.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each HTTP request.

## Actor input object example

```json
{
  "inputUrls": [
    {
      "url": "https://www.apify.com/"
    }
  ],
  "maxRetries": 5,
  "includeBackgroundImages": true,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Records scraped by Website Image Downloader Pro, 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 = {
    "inputUrls": [
        {
            "url": "https://www.apify.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/website-image-downloader-pro").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 = { "inputUrls": [{ "url": "https://www.apify.com/" }] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/website-image-downloader-pro").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 '{
  "inputUrls": [
    {
      "url": "https://www.apify.com/"
    }
  ]
}' |
apify call scrapers-hub/website-image-downloader-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/website-image-downloader-pro"
        }
    }
}

```

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/5LycypS1nfrP6aLWJ/builds/6qiWqkQtrp0ff3ZkN/openapi.json