# AgentShot (`roosch/agentshot`) Actor

Screenshot + clean markdown + metadata of a web page in one call, built for AI agents. Full-page, mobile, PDF. Pay only for successful captures.

- **URL**: https://apify.com/roosch/agentshot.md
- **Developed by:** [Justin Rooschuz](https://apify.com/roosch) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 screenshot captureds

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

## AgentShot: screenshot + markdown + metadata in one call

**AgentShot** gives you a screenshot of a web page and, if you ask, the page's main content as clean markdown plus its metadata, all in one dataset row. It's built so AI agents and LLM pipelines can see a page and read it in a single call. It also works as a precise screenshot tool:

- exact width and height, or the full page with sticky headers shown once
- mobile presets
- emoji and CJK fonts
- cookie banners hidden
- PNG, JPEG, WebP or PDF

**You're only charged for captures that succeed.** Failed, blocked, timed-out, invalid or skipped URLs cost nothing, so there's nothing to refund. Charges happen only after the files are saved. The only other charge is Apify's standard run-start fee of $0.00005 per GB of memory ($0.0001 per run at the default 2 GB).

### For AI agents (quick start)

**Minimal input:**

```json
{ "urls": ["https://example.com"], "snapshot": true }
```

**One row per URL** (abridged real output from a test run):

```json
{
  "url": "https://www.python.org/",
  "status": "success",
  "title": "Welcome to Python.org",
  "finalUrl": "https://www.python.org/",
  "httpStatus": 200,
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/<id>/records/0005-www.python.org.jpg",
  "metadata": {
    "title": "Welcome to Python.org",
    "description": "The official home of the Python Programming Language",
    "canonical": null,
    "language": "en",
    "siteName": "Python.org",
    "openGraph": { "type": "website", "site_name": "Python.org", "title": "Welcome to Python.org", "image": "https://www.python.org/static/opengraph-icon-200x200.png", "...": "..." },
    "twitter": {},
    "headings": [{ "level": 2, "text": "Get Started" }, { "level": 2, "text": "Download" }, "..."],
    "links": { "total": 227, "internal": 147, "external": 80 },
    "images": 1,
    "wordCount": 303
  },
  "contentSource": "article",
  "markdown": "# Welcome to Python.org\n\n## Download\n\nPython source code and installers are available for download for all versions! ...",
  "markdownChars": 3007,
  "markdownTruncated": false,
  "markdownUrl": "https://api.apify.com/v2/key-value-stores/<id>/records/0005-www.python.org.md",
  "warnings": [],
  "chargedEvents": ["screenshot", "snapshot"]
}
```

- **`status`** is always `success` or `failed`. Failed rows carry `error` and `charged: false`, so agents can branch on it.
- **`markdown`** is capped by `maxMarkdownChars` (default 30,000 ≈ 7–8k tokens) to fit a context window. The full text is always available at `markdownUrl`.
- **`contentSource`:**
  - `article` means the main content was detected and navigation and boilerplate were dropped.
  - `fullPage` means all visible text was kept, for pages without a clear main article such as home pages.
- **`screenshotUrl`** is a direct image link that vision models can open.

**Use it from an MCP client** (Claude, VS Code, Cursor, and others) through Apify's hosted MCP server:

```
https://mcp.apify.com?tools=roosch/agentshot
```

**Use it from code** with one synchronous HTTP call that returns the rows:

```bash
curl -X POST "https://api.apify.com/v2/acts/roosch~agentshot/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"urls":["https://example.com"],"snapshot":true}'
```

Agents without an Apify account can pay on their own through [Apify agentic payments](https://docs.apify.com/agents/payments): buy a prepaid, spend-capped Apify token with x402 (USDC on Base or Solana) or MPP (stablecoins on Tempo or Solana), or pay per call with Skyfire. AgentShot runs with limited permissions and pay-per-event pricing only, so it works with all three.

### Use it from an MCP client (Claude, Cursor, and others)

Add [Apify's MCP server](https://docs.apify.com/integrations/mcp) with just this Actor loaded:

```json
{
  "mcpServers": {
    "agentshot": {
      "url": "https://mcp.apify.com?tools=roosch/agentshot"
    }
  }
}
```

On first connection your browser opens so you can sign in to Apify. To skip sign-in, add `"headers": { "Authorization": "Bearer <APIFY_TOKEN>" }`. A prepaid token bought through [agentic payments](https://docs.apify.com/agents/payments) works there too.

Your client then gets a tool called `roosch--agentshot`. The server also adds `get-dataset-items`, `get-key-value-store-record`, `get-actor-run` and `abort-actor-run`. Example call:

```json
{ "name": "roosch--agentshot", "arguments": { "urls": ["https://example.com"], "snapshot": true } }
```

The tool returns the run's status and storage details (`status`, `runId`, `storages.datasets.default.id`, the available fields), not the dataset rows. If the run is still running, check `get-actor-run` until it finishes. Then call `get-dataset-items` with that dataset ID to get the rows described under "What you get" below: `screenshotUrl`, `markdown`, `metadata`, `chargedEvents`. Each run is billed at the prices below.

### Why this Actor

Frequent requests for screenshot tools, and how this one handles them:

| Request | What this Actor does |
|---|---|
| Set the exact image height | **Exact width and height** for viewport shots, plus 10 device presets (iPhone, Pixel, iPad, retina desktop). |
| Capture only part of a page | Capture **just one element** with a CSS selector (e.g. `#pricing`, `main`), even if it's taller than the screen. |
| Handle sticky headers | Full-page shots are **stitched as you'd scroll**. Fixed and sticky headers, chat bubbles and bottom bars appear **once**, not repeated or missing. `100vh` hero sections keep their real height. |
| Render emoji and CJK text | Ships with **Noto Color Emoji and Noto CJK fonts**, so 😀, 日本語 and 한국어 render properly. |
| Wait for the page properly | Choose `networkidle`, `load` or `domcontentloaded`. Busy sites that never go quiet are captured after a capped wait **with a warning instead of failing**. Optional wait-for-selector and extra delay. |
| Lazy images missing | Scrolls through the page first so lazy images and sections load, then waits for images and fonts. |
| Cookie pop-ups covering the page | Hides 30+ common consent tools (OneTrust, Cookiebot, Quantcast, Didomi, Usercentrics, Sourcepoint…) plus anything that looks like a consent overlay, and re-enables scrolling. **Nothing is clicked or accepted.** |
| Don't pay for failures | **Pay per successful screenshot.** Failed URLs appear in the dataset with the reason and `charged: false`. |

### What you get

For every URL, one row in the dataset:

```json
{
  "url": "https://tailwindcss.com/",
  "status": "success",
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/<id>/records/0003-tailwindcss.com.jpg",
  "pdfUrl": null,
  "title": "Tailwind CSS - Rapidly build modern websites without ever leaving your HTML.",
  "format": "image/jpeg",
  "imageWidth": 1440,
  "imageHeight": 10345,
  "fullPage": true,
  "pageHeight": 10345,
  "truncated": false,
  "device": "none",
  "httpStatus": 200,
  "warnings": [],
  "chargedEvents": ["screenshot", "full-page"],
  "capturedAt": "2026-10-11T18:21:07.000Z"
}
```

Failed URLs look like `{ "url": "...", "status": "failed", "error": "Request blocked - received 403 status code.", "charged": false }`.

The image (and the PDF, if requested) is saved in the run's key-value store. `screenshotUrl` links straight to it.

**Optional receipt (`receipt: true`, free).** Each successful row gets a `receipt` with the capture time (UTC), the settings that shaped the capture, and the SHA-256 hash and size of every saved file (screenshot, PDF, markdown). Check a file later with `sha256sum`. The receipt is written by the run itself; it is not a signed or third-party timestamp.

```json
"receipt": {
  "receiptVersion": 1,
  "capturedAt": "2026-10-12T20:15:03.412Z",
  "url": "https://example.com/",
  "finalUrl": "https://example.com/",
  "httpStatus": 200,
  "settings": { "width": 1280, "height": 800, "devicePreset": "none", "fullPage": false, "format": "png", "waitUntil": "load", "hideCookieBanners": true, "snapshot": false, "proxy": "none" },
  "files": [{ "key": "0000-example.com.png", "contentType": "image/png", "bytes": 18734, "sha256": "9f2c…" }],
  "run": { "actorId": "…", "runId": "…", "buildNumber": "1.0.5" },
  "note": "Self-reported by this Actor run; not a signed or third-party timestamp. Verify a file with: sha256sum <file>."
}
```

### Input example

```json
{
  "urls": ["https://stripe.com", "example.com", { "url": "https://www.bbc.co.uk/news" }],
  "fullPage": true,
  "width": 1440,
  "height": 900,
  "format": "webp",
  "quality": 85,
  "hideCookieBanners": true,
  "hideSelectors": ["#intercom-container", ".promo-bar"],
  "pdf": false
}
```

Mobile: set `"devicePreset": "iphone-15"`. Element only: set `"selector": "#pricing"`.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| Screenshot captured | $0.004 | Each successful screenshot (viewport or element) |
| Full-page add-on | $0.004 | When the successful screenshot is a full-page capture |
| Agent snapshot add-on | $0.002 | Each successful markdown + metadata extraction (`snapshot: true`) |
| PDF generated | $0.004 | Each successful PDF |

So 1,000 screenshots cost **$4**, 1,000 screenshot + snapshot pairs cost **$6**, and 1,000 full-page screenshots cost **$6** (plus the run-start fee above). Failed URLs cost nothing. You can cap any run with Apify's "Max cost per run" setting, and the Actor stops cleanly when it's reached.

### Limits and safeguards

These protect you from surprise costs and the sites you capture from overload:

| Setting | Default | Hard limit |
|---|---|---|
| URLs per run (`maxUrls`) | 1,000 | 10,000. Extra URLs are skipped, not charged. |
| Pages per minute (`maxRequestsPerMinute`) | 60 | 300 |
| Parallel pages (`maxConcurrency`) | Auto: 2 per GB (4 at 2 GB) | 10 |
| Retries per URL (`maxRetries`) | 1 | 3 |
| Page timeout (`navigationTimeoutSecs`) | 30 s | 120 s |
| Full-page height (`maxFullPageHeight`) | 15,000 px | 30,000 px |
| File size (`maxFileSizeMb`) | 25 MB | 50 MB. Oversized PNGs are saved as JPEG; anything still larger fails without charge. |
| Memory | 2 GB | 2 to 4 GB |

- **Early stop:** after 20 URLs, if 80% or more have failed (usually a block or outage), the run stops and the remaining URLs aren't attempted. Turn this off with `stopOnHighFailureRate: false`.
- **Private networks are blocked:** localhost, private IP ranges, cloud metadata addresses and hostnames that resolve to them are refused, including via redirects.
- **Proxies:** Apify datacenter proxy or your own proxy URLs. Residential proxy isn't supported.
- **Bad input** fails fast with a message saying what to fix, before any page is opened. Out-of-range values are adjusted and logged as warnings.

### Tips

- **Infinite-scroll pages:** full-page capture stops at `maxFullPageHeight` (default 15,000 px) and sets `truncated: true`.
- **Bot-protected sites:** some news and retail sites return 403 to cloud servers. Apify datacenter proxy or your own proxy may help, but heavily protected sites will still block. Blocked pages fail without charge. In our tests, 2 of 31 real sites (Daily Mail, New York Times) blocked us without a proxy.
- **Pop-ups that aren't cookie banners** (newsletter, sign-in): add their selectors to `hideSelectors`.
- **WebP** is limited to 16,383 px tall. Taller images are saved as PNG automatically, with a warning.
- **Dark mode:** `darkMode: true` sets `prefers-color-scheme: dark`.

### Support and reliability

- **We reply to every issue within 48 hours**, usually much sooner. Please use the Issues tab and include the run ID.
- **Daily public canary:** every day the Actor's own code captures the same 30 well-known sites, screenshot plus snapshot with no proxy. The success rate, per-site results and a check that no failed URL was charged are published in [STATUS.md](STATUS.md). Failures are listed too, including sites that block automated browsers.
- **Changelog:** every change is listed below and in [CHANGELOG.md](CHANGELOG.md).

### Changelog

- **1.0 (Oct 2026):**
  - **Agent snapshot:** clean markdown + metadata in the same row (`snapshot: true`), as its own $0.002 event.
  - Agent-friendly input, dataset and output schemas.
  - Daily canary and STATUS page.
  - 48-hour support promise.
- **0.2 (Oct 2026):**
  - Safeguards: URL cap, rate limit, file-size cap, early stop on mass failure, private-network blocking.
  - Clearer errors.
  - Automatic concurrency.
- **0.1 (Oct 2026):**
  - Stitched full-page capture, device presets, emoji/CJK fonts, consent hiding.
  - Charges only after a successful save.

### FAQ

**Is it legal?** The Actor renders publicly reachable pages the way a browser does. You choose the pages, so you are responsible for having the right to capture them and for how you use the images. That includes site terms, copyright and data-protection law if pages contain personal data. This isn't legal advice.

**Is my data kept?** Screenshots are stored in your own Apify run storage. They are subject to your Apify data-retention settings and aren't sent anywhere else.

**Does it work on every site?** No. Some sites block automated browsers, and some layouts (canvas apps, heavy animations, infinite feeds) may not capture perfectly. Failed captures are free, and warnings in each row explain anything unusual.

**How good is the markdown?** It uses Mozilla's Readability (the engine behind Firefox Reader View) to find the main content, then converts it to GitHub-flavoured markdown with links and tables kept. Pages with no clear article (home pages, app shells) fall back to all visible text. Content drawn on canvas or inside images isn't extracted.

**Does it accept cookies or log in?** No. Consent banners are hidden visually, never accepted.

**Why is a page blank or different from my browser?** Some sites serve different content by region, or block data-centre traffic. Try a proxy in the right country, add a `waitForSelector`, or add a `delayMs`.

# Changelog

This Actor's version history is a separate document: https://apify.com/roosch/agentshot/changelog.md

# Actor input Schema

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

Pages to capture, one per item. Each item may be a string URL (e.g. "https://example.com" or "stripe.com/pricing") or an object with a "url" field (as some crawlers emit). https:// is added if missing. Duplicates are removed. Private/local addresses are refused. Max 1,000 per run by default (see maxUrls). The Console list editor accepts strings; objects work via the API.

## `receipt` (type: `boolean`):

Add a 'receipt' object to each successful row: capture time (UTC), the settings that shaped the capture, and the SHA-256 hash and size of every saved file (screenshot, PDF, markdown). Useful as an audit trail, or to check a file still matches what this run saved. Self-reported by the run, not a signed timestamp. Free.

## `snapshot` (type: `boolean`):

Also return the page's main content as clean markdown plus metadata (title, description, canonical URL, language, Open Graph/Twitter tags, headings, link counts, word count) in the same dataset row. Best for AI agents and RAG: one call gives you what the page looks like and what it says. Adds the 'snapshot' event ($0.002) only when extraction succeeds.

## `maxMarkdownChars` (type: `integer`):

Caps the 'markdown' field so it fits an LLM context window (30,000 chars ≈ 7–8k tokens). The full text is always saved and linked via 'markdownUrl'.

## `markdownImages` (type: `boolean`):

Include ![alt](url) image links in the markdown. Off by default to keep text compact.

## `devicePreset` (type: `string`):

Emulate a device: viewport, pixel ratio, mobile user agent and touch. 'none' uses width/height. Example: 'iphone-15' for a mobile view.

## `width` (type: `integer`):

Viewport width in px when devicePreset is 'none'. Example: 1440.

## `height` (type: `integer`):

Viewport height in px when devicePreset is 'none'. The image is exactly this tall unless fullPage is true. Example: 900.

## `fullPage` (type: `boolean`):

Capture the whole scrollable page: stitched, lazy content loaded, sticky headers shown once. Adds the 'full-page' event ($0.002).

## `maxFullPageHeight` (type: `integer`):

Safety cap for infinite-scroll pages. Taller pages are cut and flagged as truncated.

## `fixStickyElements` (type: `boolean`):

In full-page mode, fixed and sticky elements (headers, chat bubbles, bottom bars) appear at the top only instead of repeating down the image.

## `selector` (type: `string`):

Optional CSS selector. Screenshot only the first visible matching element, e.g. 'main', '#pricing', 'table.infobox'.

## `format` (type: `string`):

Image format. png = lossless (default), jpeg = small files, webp = smallest (max 16,383 px tall).

## `quality` (type: `integer`):

JPEG/WebP quality 1–100. Ignored for PNG.

## `pdf` (type: `boolean`):

Render the page to PDF as well (screen styles, backgrounds on). Adds the 'pdf' event.

## `pdfFormat` (type: `string`):

Paper size for the PDF.

## `waitUntil` (type: `string`):

networkidle = wait until the network is quiet (capped at 10 s, then continues instead of failing). load = page load event. domcontentloaded = fastest.

## `navigationTimeoutSecs` (type: `integer`):

If the page has not finished loading by then, the Actor captures what has rendered and adds a warning instead of failing.

## `waitForSelector` (type: `string`):

Optional. Wait until this element is visible before capturing. If it never appears, the URL fails and is not charged.

## `delayMs` (type: `integer`):

Extra wait in milliseconds after the page has loaded, before capture. Example: 2000 for pages with animations.

## `scrollToBottom` (type: `boolean`):

Scroll through the page first so lazy-loaded images and sections render.

## `hideCookieBanners` (type: `boolean`):

Hides 30+ common consent tools (OneTrust, Cookiebot, Quantcast, Didomi, Usercentrics…) plus consent-looking overlays. Nothing is clicked or accepted.

## `hideSelectors` (type: `array`):

Optional CSS selectors to hide (chat widgets, promo bars…).

## `customCss` (type: `string`):

Optional CSS injected before capture.

## `darkMode` (type: `boolean`):

Emulate prefers-color-scheme: dark.

## `blockAds` (type: `boolean`):

Abort requests to common ad/tracking networks for cleaner, faster shots.

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

How many pages to render at once. Leave empty (or 0) for automatic: 2 per GB of memory (4 at the default 2 GB). Higher values need more memory.

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

Retries for a URL that fails (timeouts, network errors). Failed URLs are never charged.

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

Safety cap. URLs beyond this are skipped (and not charged). Hard limit 10,000.

## `maxRequestsPerMinute` (type: `integer`):

Rate limit across the whole run, to stay polite to the sites you capture. Hard limit 300.

## `sameDomainDelaySecs` (type: `integer`):

Spacing between requests to the same domain. Useful for long lists from one site.

## `maxFileSizeMb` (type: `integer`):

PNG screenshots over this size are saved as JPEG instead; anything still larger fails (not charged). Hard limit 50.

## `stopOnHighFailureRate` (type: `boolean`):

After 20 URLs, stop the run if 80% or more have failed (usually a block or outage). Remaining URLs are not attempted or charged.

## `proxyConfiguration` (type: `object`):

Optional. Apify datacenter proxy or your own proxy URLs, for geo-specific or bot-protected pages. Residential proxy is not supported.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "receipt": false,
  "snapshot": false,
  "maxMarkdownChars": 30000,
  "markdownImages": false,
  "devicePreset": "none",
  "width": 1280,
  "height": 800,
  "fullPage": false,
  "maxFullPageHeight": 15000,
  "fixStickyElements": true,
  "format": "png",
  "quality": 85,
  "pdf": false,
  "pdfFormat": "A4",
  "waitUntil": "networkidle",
  "navigationTimeoutSecs": 30,
  "delayMs": 0,
  "scrollToBottom": true,
  "hideCookieBanners": true,
  "darkMode": false,
  "blockAds": false,
  "maxRetries": 1,
  "maxUrls": 1000,
  "maxRequestsPerMinute": 60,
  "sameDomainDelaySecs": 0,
  "maxFileSizeMb": 25,
  "stopOnHighFailureRate": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

JSON rows: url, status, screenshotUrl, title, metadata, markdown, markdownUrl, warnings, chargedEvents. Failed rows have status 'failed', an 'error' and charged=false.

## `files` (type: `string`):

Key-value store holding the screenshot images, PDFs and full markdown files referenced by the result rows.

# 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": [
        "https://apify.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("roosch/agentshot").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": ["https://apify.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("roosch/agentshot").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": [
    "https://apify.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call roosch/agentshot --silent --output-dataset

```

## MCP server setup

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

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/uRkTSo4D5Zjjsvwwt/builds/EeHuQwWTsPtcoNPQX/openapi.json