# 🔥 Website Screenshot Generator (`extractmaster01/website-screenshot-generator`) Actor

\[🥇 high-quality 🏆] Website Screenshot generator for full-page, viewport, and element screenshots. Capture websites as PNG, JPEG, WebP, or PDF with mobile emulation, metadata extraction, and batch processing.

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

## Pricing

from $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Screenshot Generator

Capture high-quality screenshots of any website at scale. Generate full-page screenshots, viewport screenshots, or capture a specific page element. Supports desktop and mobile devices, with output in PNG, JPEG, WebP, or PDF.

Perfect for website monitoring, SEO audits, QA testing, competitor tracking, visual regression testing, website archiving, and thumbnail generation.

---

### Why this Actor

Most screenshot tools give you a raw image and stop there. This one delivers results that are actually ready to use:

- **Mobile screenshots that look right** — sites respond with their actual mobile layout, not a squished desktop version
- **PDFs that match what you see in the browser** — no layout surprises, no font changes
- **Clean images by default** — cookie banners, popups, and overlays are handled before capture
- **Metadata included in every result** — title, description, Open Graph tags, and canonical URL come with each screenshot at no extra step

---

### What you can capture

- **Full page** — the entire content from top to bottom, including what's below the fold
- **Viewport** — only what's visible on screen when the page first loads
- **Element** — a single part of the page by CSS selector: a chart, a hero image, a pricing card

---

### Features

- **11 device presets** — iPhone 15 Pro, iPhone 14, iPhone SE, Pixel 7, Samsung Galaxy S23, iPad Pro, iPad Mini, and 4 desktop sizes; or set any custom width and height
- **4 output formats** — PNG, JPEG, WebP, and PDF
- **Lazy content support** — captures images and content that only appear after scrolling
- **Smart wait** — knows when the page has truly finished loading before capturing
- **Carousel and slider support** — captures animated sections at their best visible state
- **Cookie banner auto-dismiss** — covers OneTrust, Didomi, Cookiebot, CookieYes, Quantcast, and more
- **Element hiding** — remove any element before capture: chat widgets, floating banners, overlays
- **Ad and tracker blocking** — cleaner screenshots with distractions removed
- **Dark mode support** — captures the dark version of any site that supports it
- **Custom CSS** — override any style before the screenshot is taken
- **Authenticated pages** — pass session cookies to capture logged-in or personalized content
- **Custom HTTP headers** — add tokens, flags, or any header your target site needs
- **Redirect tracking** — records both the original URL and the final destination
- **Batch processing** — up to 1,000 URLs per run with adjustable concurrency
- **Retry on failure** — automatically retries flaky or slow pages
- **Apify Proxy support** — for sites that block automated requests

---

### Use cases

**Website monitoring** — schedule regular runs to detect visual changes, layout breaks, or content updates. Every run creates a timestamped archive you can compare over time.

**Competitive intelligence** — capture competitor landing pages, pricing pages, and product listings at scale. No manual browsing.

**QA and visual testing** — verify how your site looks across iPhone, Android, and desktop before every release.

**Thumbnail and preview generation** — generate website preview images for link cards, OG images, or any product that needs a visual of a URL.

**SEO and content audits** — get a screenshot and full metadata for hundreds of URLs in a single run.

**Compliance and archiving** — save visual records of web pages for legal, regulatory, or historical purposes.

**Bug reporting** — document rendering issues across viewports and send a link, not a description.

---

### Quickstart

1. Add one or more URLs to the `urls` field
2. Choose a device preset and output format
3. Click **Start** — results appear in the dataset as they complete

Each run produces a public screenshot URL and a metadata row per page. Export as JSON, CSV, or Excel.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | URL[] | — | URLs to capture. Required. |
| `screenshotType` | string | `fullPage` | `fullPage`, `viewport`, or `element` |
| `format` | string | `png` | `png`, `jpeg`, `webp`, or `pdf` |
| `quality` | integer | `85` | Quality for JPEG and WebP (1–100). Ignored for PNG and PDF. |
| `device` | string | `Desktop 1920x1080` | Device preset. See table below. Use `custom` for manual dimensions. |
| `viewportWidth` | integer | `1280` | Width in pixels. Only when `device` is `custom`. |
| `viewportHeight` | integer | `1080` | Height in pixels. Only when `device` is `custom`. |
| `selector` | string | — | CSS selector. Required when `screenshotType` is `element`. |
| `waitUntil` | string | `load` | `load`, `domcontentloaded`, `networkidle`, `networkidle0`, `networkidle2` |
| `waitForSelector` | string | — | Wait for this element to appear before capturing. |
| `delay` | integer | `0` | Extra wait in ms before capture. Max 3,600,000. |
| `waitForImages` | boolean | `false` | Wait for all images to load. Recommended for carousels and galleries. |
| `scrollToBottom` | boolean | `false` | Scroll to the bottom before capturing. |
| `delayAfterScrolling` | integer | `2500` | Wait in ms after scrolling. Used when network idle is off. |
| `waitUntilNetworkIdleAfterScroll` | boolean | `false` | Wait for the page to settle after scrolling instead of a fixed delay. |
| `waitUntilNetworkIdleAfterScrollTimeout` | integer | `30000` | Max ms to wait after scrolling. |
| `blockCookieBanners` | boolean | `true` | Auto-dismiss cookie banners before capture. |
| `selectorsToHide` | string | — | CSS selectors to hide before capture. e.g. `.chat-widget, #cookie-bar` |
| `blockAds` | boolean | `false` | Remove ads and trackers before capturing. |
| `darkMode` | boolean | `false` | Capture the site in dark mode. |
| `javascript` | boolean | `true` | Run JavaScript on the page. Disable for faster captures on static sites. |
| `extractMetadata` | boolean | `true` | Include title, description, OG tags, canonical URL, and language in results. |
| `customHeaders` | object | `{}` | HTTP headers to send. e.g. `{"Authorization": "Bearer TOKEN"}` |
| `cookies` | array | `[]` | Cookies to inject before navigating. Each needs `name`, `value`, and `domain`. |
| `injectCss` | string | — | CSS to apply before capture. |
| `timeout` | integer | `30000` | Page load timeout in ms (5,000–120,000). |
| `maxRetries` | integer | `10` | Retries per failed URL. |
| `maxConcurrency` | integer | `3` | Simultaneous pages. Higher is faster but uses more memory. |
| `maxItems` | integer | — | Stop after this many screenshots. Leave empty for no limit. |
| `proxyConfiguration` | object | — | Apify Proxy or custom proxy URL. |

#### Device presets

| Preset | Viewport | Mobile | Touch |
|---|---|---|---|
| `Desktop 1920x1080` | 1920×1080 | — | — |
| `Desktop 1440x900` | 1440×900 | — | — |
| `Desktop 1280x800` | 1280×800 | — | — |
| `Laptop 1366x768` | 1366×768 | — | — |
| `iPhone 15 Pro` | 393×852 | ✓ | ✓ |
| `iPhone 14` | 390×844 | ✓ | ✓ |
| `iPhone SE` | 375×667 | ✓ | ✓ |
| `Pixel 7` | 412×915 | ✓ | ✓ |
| `Samsung Galaxy S23` | 360×780 | ✓ | ✓ |
| `iPad Pro 12.9` | 1024×1366 | — | ✓ |
| `iPad Mini` | 768×1024 | — | ✓ |
| `custom` | `viewportWidth` × `viewportHeight` | — | — |

---

### Output

Each URL produces one dataset row and one file in the Key-Value Store.

| Field | Type | Description |
|---|---|---|
| `startUrl` | string | Original input URL |
| `url` | string | Final URL after redirects |
| `screenshotUrl` | string | Public direct-download link |
| `screenshotKey` | string | Key in the Key-Value Store |
| `format` | string | `png`, `jpeg`, `webp`, or `pdf` |
| `screenshotType` | string | `fullPage`, `viewport`, or `element` |
| `viewport` | object | `{ width, height }` used for capture |
| `device` | string | Device preset name |
| `title` | string | Page title |
| `description` | string | Meta description |
| `ogTitle` | string | Open Graph title |
| `ogImage` | string | Open Graph image URL |
| `ogDescription` | string | Open Graph description |
| `canonicalUrl` | string | Canonical URL |
| `language` | string | Page language |
| `timestamp` | string | ISO 8601 capture time |
| `success` | boolean | `true` on success |
| `error` | string | Error message if `success` is `false` |

#### Sample output

```json
{
    "startUrl": "https://example.com",
    "url": "https://example.com/",
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/screenshot_example_com_a1b2c3d4.png",
    "screenshotKey": "screenshot_example_com_a1b2c3d4.png",
    "format": "png",
    "screenshotType": "fullPage",
    "viewport": { "width": 1920, "height": 1080 },
    "device": "Desktop 1920x1080",
    "title": "Example Domain",
    "description": "This domain is for use in illustrative examples.",
    "ogTitle": null,
    "ogImage": null,
    "canonicalUrl": "https://example.com/",
    "language": "en",
    "timestamp": "2026-01-15T12:00:00.000Z",
    "success": true
}
````

***

### Tips

**JavaScript-heavy sites and SPAs:** Use `waitUntil: "networkidle"` for React, Vue, and Angular apps. The default (`load`) works for most sites — switch to `networkidle` only if content is missing after capture.

**Lazy-loaded content:** Enable `scrollToBottom: true`. Add `waitUntilNetworkIdleAfterScroll: true` for the smartest possible wait — no fixed delay needed.

**Carousels, sliders, and hero animations:** Enable `waitForImages: true` to make sure every visual element is ready before the screenshot is taken.

**Cookie banners not auto-dismissed:** Add the banner's CSS selector to `selectorsToHide`. For example: `.cookie-overlay, #consent-modal`.

**Authenticated pages:** Pass session cookies in the `cookies` field. Get them from your browser's DevTools after logging in (Application → Cookies).

**Mobile screenshots:** Pick a device preset. The site will respond as if a real phone is visiting — you get the actual mobile layout, not a resized desktop.

**Bot detection:** Enable Apify Proxy (residential) in `proxyConfiguration` for sites that block automated visitors.

**Large file sizes:** Use `format: "webp"` for the smallest files, or `format: "pdf"` for printable output.

**Cost control:** Set `maxItems` to limit the total screenshots per run. Adjust `maxConcurrency` based on available memory.

**Capturing one section of a page:** Use `screenshotType: "element"` with a `selector` like `#pricing-table` or `.hero-section`.

***

### Pricing

**$3.00 per 1,000 successful screenshots.**

You are never charged for pages that fail or time out. The Actor stops automatically when it reaches your spending limit in Apify Console.

***

### Limitations

- Sites with aggressive bot protection may require residential proxies
- Very long pages produce large PNG files — use WebP or PDF for those
- Cookie injection works for session-based authentication only; it cannot fill and submit a login form

***

### API usage

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('YOUR_USERNAME/screenshot-url').call({
    urls: [
        { url: 'https://example.com' },
        { url: 'https://news.ycombinator.com' },
    ],
    screenshotType: 'fullPage',
    format: 'png',
    device: 'iPhone 15 Pro',
    blockCookieBanners: true,
    waitForImages: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].screenshotUrl);
```

***

### Scheduling

Go to **Schedules** in the Apify Console, point it at this Actor, and set your cron expression. Every run produces a new timestamped set of screenshots — useful for visual monitoring over time.

***

### Frequently asked questions

**Do I get charged if a page fails?**
No. Only successful screenshots are charged.

**What is the difference between fullPage and viewport?**
`fullPage` captures everything from top to bottom. `viewport` captures only what is visible when the page first loads.

**Can I take mobile screenshots?**
Yes. Choose any mobile preset and the site will respond with its actual mobile layout.

**Why does the PDF look exactly like the screenshot?**
By design. The PDF preserves the visual appearance of the page as captured, not the browser's print version.

**How do I hide a cookie banner?**
Automatic dismissal is on by default. For anything not covered, add the selector to `selectorsToHide`.

**Can I screenshot a page behind a login?**
Yes, using session cookies. Pass them in the `cookies` field after grabbing them from your browser.

**How fast does it run?**
With `maxConcurrency: 3`, three pages run in parallel. Most complete in 10–40 seconds depending on the site.

**What happens to screenshots after the run?**
They are stored in the run's Key-Value Store. Each dataset row has a `screenshotUrl` — a direct public link.

**Does it work without a proxy?**
Yes, for most public websites. Enable proxy only if the site blocks automated visitors.

***

### You might also like

If you found this Actor useful, you might also like:

**[Apify Store Scraper](https://apify.com/extractmaster01/apify-store-scraper)** — Extract Actor listings, pricing, ratings, and metadata from the Apify Store. Ideal for market research, competitor tracking, and finding automation opportunities.

**[Website Contact Scraper](https://apify.com/extractmaster01/website-contact-scraper)** — Extract email addresses, phone numbers, and social media links from any website. Great for lead generation and outreach campaigns.

**[Google Ads Scraper](https://apify.com/extractmaster01/google-ads-scraper)** — Collect Google Ads data at scale. See what competitors are bidding on, what creatives they run, and how their ads are structured.

***

### Feedback

Found a bug or want a feature? Open an issue in the **Issues** tab. We respond within 2 business days.

# Actor input Schema

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

List of URLs to screenshot. Supports up to 1000 URLs per run.

## `screenshotType` (type: `string`):

What to capture: the full scrollable page, the visible viewport only, or a specific element by CSS selector.

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

Image format. PNG is lossless. JPEG/WebP produce smaller files. PDF embeds the screenshot as an image inside a PDF page — visually identical to the PNG output, not a print layout.

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

Compression quality for JPEG and WebP formats (1–100). Higher = better quality, larger file. Ignored for PNG and PDF.

## `device` (type: `string`):

Emulate a specific device for responsive screenshots. Sets viewport, User-Agent, and touch support automatically. Use 'custom' to set your own dimensions.

## `viewportWidth` (type: `integer`):

Browser width in pixels. Only used when Device is set to 'Custom'.

## `viewportHeight` (type: `integer`):

Browser height in pixels. Only used when Device is set to 'Custom'.

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

CSS selector of the element to screenshot. Only used when Screenshot Type is 'Specific Element'. Example: '#hero-section' or '.product-card:first-child'

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

When to consider the page ready for capture. 'load' works for most sites and is the recommended default. 'networkidle' waits until no network requests for 500 ms — best for SPAs and React/Vue/Angular apps, but may time out on news or ad-heavy sites. 'networkidle0' and 'networkidle2' are accepted as aliases for 'networkidle'.

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

Wait for a specific CSS selector to appear before capturing. Useful for dynamic/lazy content. Example: '.product-list' or '#main-content'

## `delay` (type: `integer`):

Extra wait time in milliseconds after page load before taking the screenshot. Useful for CSS animations or deferred rendering (e.g., 1000 = 1 second).

## `waitForImages` (type: `boolean`):

Wait for all images on the page to finish loading before capturing. Enable this for sites with carousels, lazy-loaded galleries, or hero images that render after the load event via JavaScript.

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

Scroll to the bottom of the page before capturing to trigger lazy-loaded images, carousels, and infinite scroll content.

## `delayAfterScrolling` (type: `integer`):

Wait time in milliseconds after scrolling to bottom. Only applies when 'Scroll to Bottom' is enabled and 'Wait for Network Idle After Scroll' is disabled.

## `waitUntilNetworkIdleAfterScroll` (type: `boolean`):

After scrolling to the bottom, wait until the network goes quiet (no requests for 500 ms) before capturing. Smarter than a fixed delay — catches lazy-loaded images and API calls triggered by scroll. Overrides 'Delay After Scrolling' when enabled.

## `waitUntilNetworkIdleAfterScrollTimeout` (type: `integer`):

Maximum time to wait for network idle after scrolling. Only used when 'Wait for Network Idle After Scroll' is enabled. If the timeout is exceeded, the capture continues anyway.

## `blockCookieBanners` (type: `boolean`):

Automatically click 'Accept' on GDPR/cookie consent banners (OneTrust, Didomi, Cookiebot, CookieYes, and 10+ others) for cleaner screenshots.

## `selectorsToHide` (type: `string`):

Comma-separated CSS selectors of elements to hide before capturing. Useful for persistent banners, chat widgets, or overlays. Example: '.cookie-banner, #intercom-frame, .chat-widget'

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

Block ad networks and tracking scripts (Google Ads, Taboola, Hotjar, Mixpanel, etc.) for cleaner and faster screenshots.

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

Emulate 'prefers-color-scheme: dark' to capture the site's dark theme.

## `javascript` (type: `boolean`):

Execute JavaScript on the page. Disable for static HTML-only pages to speed up captures.

## `extractMetadata` (type: `boolean`):

Extract page title, meta description, Open Graph image, canonical URL, and language alongside each screenshot.

## `customHeaders` (type: `object`):

Custom HTTP headers to send with each request. Useful for authentication tokens or A/B test overrides. Example: {"Authorization": "Bearer TOKEN", "X-Custom-Header": "value"}

## `cookies` (type: `array`):

Cookies to inject before navigating. Use for authenticated sessions. Each item must have 'name', 'value', and 'domain'. Example: \[{"name": "session", "value": "abc123", "domain": ".example.com"}]

## `injectCss` (type: `string`):

Custom CSS injected into the page before capturing. Use to hide elements, change fonts, or override styles. Example: '.popup { display: none !important; } body { font-size: 16px; }'

## `timeout` (type: `integer`):

Maximum time in milliseconds to wait for a page to load before failing. Increase for slow sites (e.g., 60000 = 60 seconds).

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

Number of times to retry a failed URL. Higher values improve reliability on flaky or slow sites. Recommended: 10 for production.

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

Maximum number of browser tabs running simultaneously. Higher = faster, but uses more memory. Recommended: 3 for stability, 5+ for speed with sufficient memory.

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

Maximum number of screenshots to capture. Useful for testing or cost control. Leave empty for no limit.

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

Proxy settings for bypassing geo-restrictions or bot detection. Most sites work without a proxy. Enable Apify Proxy or your own if you encounter blocks.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://example.com"
    }
  ],
  "screenshotType": "fullPage",
  "format": "png",
  "quality": 85,
  "device": "Desktop 1920x1080",
  "viewportWidth": 1280,
  "viewportHeight": 1080,
  "selector": "",
  "waitUntil": "load",
  "waitForSelector": "",
  "delay": 0,
  "waitForImages": false,
  "scrollToBottom": false,
  "delayAfterScrolling": 2500,
  "waitUntilNetworkIdleAfterScroll": false,
  "waitUntilNetworkIdleAfterScrollTimeout": 30000,
  "blockCookieBanners": true,
  "selectorsToHide": "",
  "blockAds": false,
  "darkMode": false,
  "javascript": true,
  "extractMetadata": true,
  "customHeaders": {},
  "cookies": [],
  "injectCss": "",
  "timeout": 30000,
  "maxRetries": 10,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

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

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

# Run the Actor and wait for it to finish
run = client.actor("extractmaster01/website-screenshot-generator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    {
      "url": "https://example.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call extractmaster01/website-screenshot-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=extractmaster01/website-screenshot-generator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🔥 Website Screenshot Generator",
        "description": "[🥇 high-quality 🏆] Website Screenshot generator for full-page, viewport, and element screenshots. Capture websites as PNG, JPEG, WebP, or PDF with mobile emulation, metadata extraction, and batch processing.",
        "version": "0.1",
        "x-build-id": "iimYsFcqxVaudUv8e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/extractmaster01~website-screenshot-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-extractmaster01-website-screenshot-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/extractmaster01~website-screenshot-generator/runs": {
            "post": {
                "operationId": "runs-sync-extractmaster01-website-screenshot-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/extractmaster01~website-screenshot-generator/run-sync": {
            "post": {
                "operationId": "run-sync-extractmaster01-website-screenshot-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "URLs",
                        "type": "array",
                        "description": "List of URLs to screenshot. Supports up to 1000 URLs per run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "screenshotType": {
                        "title": "Screenshot Type",
                        "enum": [
                            "fullPage",
                            "viewport",
                            "element"
                        ],
                        "type": "string",
                        "description": "What to capture: the full scrollable page, the visible viewport only, or a specific element by CSS selector.",
                        "default": "fullPage"
                    },
                    "format": {
                        "title": "Output Format",
                        "enum": [
                            "png",
                            "jpeg",
                            "webp",
                            "pdf"
                        ],
                        "type": "string",
                        "description": "Image format. PNG is lossless. JPEG/WebP produce smaller files. PDF embeds the screenshot as an image inside a PDF page — visually identical to the PNG output, not a print layout.",
                        "default": "png"
                    },
                    "quality": {
                        "title": "JPEG/WebP Quality",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Compression quality for JPEG and WebP formats (1–100). Higher = better quality, larger file. Ignored for PNG and PDF.",
                        "default": 85
                    },
                    "device": {
                        "title": "Device Preset",
                        "enum": [
                            "custom",
                            "Desktop 1920x1080",
                            "Desktop 1440x900",
                            "Desktop 1280x800",
                            "Laptop 1366x768",
                            "iPhone 15 Pro",
                            "iPhone 14",
                            "iPhone SE",
                            "Pixel 7",
                            "Samsung Galaxy S23",
                            "iPad Pro 12.9",
                            "iPad Mini"
                        ],
                        "type": "string",
                        "description": "Emulate a specific device for responsive screenshots. Sets viewport, User-Agent, and touch support automatically. Use 'custom' to set your own dimensions.",
                        "default": "Desktop 1920x1080"
                    },
                    "viewportWidth": {
                        "title": "Custom Viewport Width (px)",
                        "minimum": 100,
                        "maximum": 3840,
                        "type": "integer",
                        "description": "Browser width in pixels. Only used when Device is set to 'Custom'.",
                        "default": 1280
                    },
                    "viewportHeight": {
                        "title": "Custom Viewport Height (px)",
                        "minimum": 200,
                        "maximum": 2160,
                        "type": "integer",
                        "description": "Browser height in pixels. Only used when Device is set to 'Custom'.",
                        "default": 1080
                    },
                    "selector": {
                        "title": "CSS Selector (Element Screenshot)",
                        "type": "string",
                        "description": "CSS selector of the element to screenshot. Only used when Screenshot Type is 'Specific Element'. Example: '#hero-section' or '.product-card:first-child'",
                        "default": ""
                    },
                    "waitUntil": {
                        "title": "Wait Until",
                        "enum": [
                            "load",
                            "domcontentloaded",
                            "networkidle",
                            "networkidle0",
                            "networkidle2"
                        ],
                        "type": "string",
                        "description": "When to consider the page ready for capture. 'load' works for most sites and is the recommended default. 'networkidle' waits until no network requests for 500 ms — best for SPAs and React/Vue/Angular apps, but may time out on news or ad-heavy sites. 'networkidle0' and 'networkidle2' are accepted as aliases for 'networkidle'.",
                        "default": "load"
                    },
                    "waitForSelector": {
                        "title": "Wait For Selector",
                        "type": "string",
                        "description": "Wait for a specific CSS selector to appear before capturing. Useful for dynamic/lazy content. Example: '.product-list' or '#main-content'",
                        "default": ""
                    },
                    "delay": {
                        "title": "Delay Before Capture (ms)",
                        "minimum": 0,
                        "maximum": 3600000,
                        "type": "integer",
                        "description": "Extra wait time in milliseconds after page load before taking the screenshot. Useful for CSS animations or deferred rendering (e.g., 1000 = 1 second).",
                        "default": 0
                    },
                    "waitForImages": {
                        "title": "Wait for Images to Load",
                        "type": "boolean",
                        "description": "Wait for all images on the page to finish loading before capturing. Enable this for sites with carousels, lazy-loaded galleries, or hero images that render after the load event via JavaScript.",
                        "default": false
                    },
                    "scrollToBottom": {
                        "title": "Scroll to Bottom (Lazy Load)",
                        "type": "boolean",
                        "description": "Scroll to the bottom of the page before capturing to trigger lazy-loaded images, carousels, and infinite scroll content.",
                        "default": false
                    },
                    "delayAfterScrolling": {
                        "title": "Delay After Scrolling (ms)",
                        "minimum": 0,
                        "maximum": 3600000,
                        "type": "integer",
                        "description": "Wait time in milliseconds after scrolling to bottom. Only applies when 'Scroll to Bottom' is enabled and 'Wait for Network Idle After Scroll' is disabled.",
                        "default": 2500
                    },
                    "waitUntilNetworkIdleAfterScroll": {
                        "title": "Wait for Network Idle After Scroll",
                        "type": "boolean",
                        "description": "After scrolling to the bottom, wait until the network goes quiet (no requests for 500 ms) before capturing. Smarter than a fixed delay — catches lazy-loaded images and API calls triggered by scroll. Overrides 'Delay After Scrolling' when enabled.",
                        "default": false
                    },
                    "waitUntilNetworkIdleAfterScrollTimeout": {
                        "title": "Network Idle After Scroll Timeout (ms)",
                        "minimum": 1000,
                        "maximum": 3600000,
                        "type": "integer",
                        "description": "Maximum time to wait for network idle after scrolling. Only used when 'Wait for Network Idle After Scroll' is enabled. If the timeout is exceeded, the capture continues anyway.",
                        "default": 30000
                    },
                    "blockCookieBanners": {
                        "title": "Auto-dismiss Cookie Banners",
                        "type": "boolean",
                        "description": "Automatically click 'Accept' on GDPR/cookie consent banners (OneTrust, Didomi, Cookiebot, CookieYes, and 10+ others) for cleaner screenshots.",
                        "default": true
                    },
                    "selectorsToHide": {
                        "title": "CSS Selectors to Hide",
                        "type": "string",
                        "description": "Comma-separated CSS selectors of elements to hide before capturing. Useful for persistent banners, chat widgets, or overlays. Example: '.cookie-banner, #intercom-frame, .chat-widget'",
                        "default": ""
                    },
                    "blockAds": {
                        "title": "Block Ads & Trackers",
                        "type": "boolean",
                        "description": "Block ad networks and tracking scripts (Google Ads, Taboola, Hotjar, Mixpanel, etc.) for cleaner and faster screenshots.",
                        "default": false
                    },
                    "darkMode": {
                        "title": "Dark Mode",
                        "type": "boolean",
                        "description": "Emulate 'prefers-color-scheme: dark' to capture the site's dark theme.",
                        "default": false
                    },
                    "javascript": {
                        "title": "Enable JavaScript",
                        "type": "boolean",
                        "description": "Execute JavaScript on the page. Disable for static HTML-only pages to speed up captures.",
                        "default": true
                    },
                    "extractMetadata": {
                        "title": "Extract Page Metadata",
                        "type": "boolean",
                        "description": "Extract page title, meta description, Open Graph image, canonical URL, and language alongside each screenshot.",
                        "default": true
                    },
                    "customHeaders": {
                        "title": "Custom HTTP Headers",
                        "type": "object",
                        "description": "Custom HTTP headers to send with each request. Useful for authentication tokens or A/B test overrides. Example: {\"Authorization\": \"Bearer TOKEN\", \"X-Custom-Header\": \"value\"}",
                        "default": {}
                    },
                    "cookies": {
                        "title": "Cookies",
                        "type": "array",
                        "description": "Cookies to inject before navigating. Use for authenticated sessions. Each item must have 'name', 'value', and 'domain'. Example: [{\"name\": \"session\", \"value\": \"abc123\", \"domain\": \".example.com\"}]",
                        "default": []
                    },
                    "injectCss": {
                        "title": "Inject CSS",
                        "type": "string",
                        "description": "Custom CSS injected into the page before capturing. Use to hide elements, change fonts, or override styles. Example: '.popup { display: none !important; } body { font-size: 16px; }'",
                        "default": ""
                    },
                    "timeout": {
                        "title": "Page Load Timeout (ms)",
                        "minimum": 5000,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Maximum time in milliseconds to wait for a page to load before failing. Increase for slow sites (e.g., 60000 = 60 seconds).",
                        "default": 30000
                    },
                    "maxRetries": {
                        "title": "Retries on Failure",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of times to retry a failed URL. Higher values improve reliability on flaky or slow sites. Recommended: 10 for production.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of browser tabs running simultaneously. Higher = faster, but uses more memory. Recommended: 3 for stability, 5+ for speed with sufficient memory.",
                        "default": 3
                    },
                    "maxItems": {
                        "title": "Max Screenshots",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of screenshots to capture. Useful for testing or cost control. Leave empty for no limit."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for bypassing geo-restrictions or bot detection. Most sites work without a proxy. Enable Apify Proxy or your own if you encounter blocks."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
