# Website Screenshot API with Size and Time Limits (`jungle_cleric/money-venture-website-screenshots`) Actor

Capture public web pages as PNG images. Set exact dimensions or page-height and scroll limits. Get image links, limit flags, and failed-page details.

- **URL**: https://apify.com/jungle_cleric/money-venture-website-screenshots.md
- **Developed by:** [Ying Qi Mah](https://apify.com/jungle_cleric) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 saved png screenshots

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

## Website Screenshot API with Size and Time Limits

Capture a public web page as a PNG image. Choose exact viewport dimensions or a page region with a height and scrolling limit. The Actor returns image links and capture metadata.

The Actor accepts one to 50 URLs per run. It saves one result row for each successful PNG image. Read the limits below before you start a large batch.

### Price

The Actor uses Pay Per Event pricing.

The price is $0.004 per saved image ($4 per 1,000 images), plus $0.01 per run. The startup fee also applies when every page fails. At the fixed 1 GB memory setting, a run with one image would cost $0.014. A run with 50 images would cost $0.21. Check the Console price before starting a run.

The Actor uses fixed Pay Per Event pricing. It does not add platform usage to the event price. Apify can charge separately for later storage access or export.

### Quick start

Enter a public page URL and keep Exact viewport mode for a fixed-size image. The default is 1280 × 720 pixels.

```json
{
  "urls": [{ "url": "https://example.com/" }],
  "mode": "viewport",
  "width": 1280,
  "height": 720
}
```

Open Captured images after the run. Each row links to a PNG file. Open Run summary and errors for failed pages. A failed page does not produce a result row. The Actor continues after one page failure. Two page failures in a row stop the run.

### Capture modes

| Mode | Output |
| --- | --- |
| `viewport` | Exactly the requested width and height. A taller page is intentionally cropped. The browser does not scroll. |
| `boundedPage` | Captures from the page top with a height cap. The browser scrolls within the configured time and step limits, then returns to the top. |

Page mode defaults to an 8,000-pixel height cap, 12 scroll steps, and a 1.5-second scroll time limit. A height cap or stopped scroll can leave content outside the image. The output reports those limits. An observed page bottom does not prove that all lazy content loaded.

Widths can be 100–1920 pixels. Viewport heights can be 100–1080 pixels. Page captures can be at most 12,000 pixels high. Duplicate normalized URLs are skipped within a run.

### Loading and time limits

The default readiness setting is `load`. The faster `domcontentloaded` setting can capture before styles or images finish loading.

Defaults are 10 seconds for navigation, 10 seconds for the capture stage, and 20 seconds for combined browser work per page. Storage is separate from the browser-work limit. The Actor permits at most 60 seconds of runner work. It stops page work by 75 seconds from platform start. An 85-second safety timer ends the process if cleanup stalls. The default platform timeout is 90 seconds. A lower user timeout can end the run sooner. If a page times out, its details appear in the run summary.

Each page has a 5 MiB traffic limit. MiB means 1,048,576 bytes. The limit includes browser requests, remote replies, and connection overhead. The proxy closes connections when the limit is crossed. In-flight buffers can exceed the limit slightly. A PNG file above 2 MiB is rejected. These limits can reject pages with many assets or large images.

Images, fonts, and style sheets load normally. The Actor does not automatically accept cookie prompts or remove overlays. An image can therefore include those prompts.

### Output fields

| Fields | Meaning |
| --- | --- |
| `url`, `finalUrl`, `httpStatus` | Requested URL, final page URL, and successful navigation status. |
| `screenshotUrl`, `screenshotKey`, `contentType`, `imageBytes` | PNG file link, storage key, MIME type, and byte count. |
| `capturedAt`, `pageElapsedMs`, `elapsedMs` | Capture timestamp, combined browser-work duration, and capture-stage duration. Times use milliseconds. |
| `networkBytes` | Proxy traffic counted for this page. This includes connection overhead. |
| `mode`, `width`, `height` | Requested mode and actual PNG dimensions. |
| `documentSize` | Observed page width, height, and scroll position after capture. |
| `croppedToViewport` | The page was taller than the requested viewport image. |
| `heightLimitReached` | The page exceeded the configured page-mode height cap. |
| `layoutChangedDuringCapture` | Document dimensions changed between the pre-image and post-image observations. |
| `scroll.steps`, `scroll.stopReason` | Scroll count and stop reason: disabled, bottom observed, step limit, or time limit. |

`RUN_SUMMARY` records successful results, failed URLs, duplicate inputs, total proxy traffic, and early-stop reasons. `unprocessedUrls` lists inputs with no final result. A partial batch can occur when a time, failure, or charge limit stops work. Submit only the remaining URLs in a later run.

Failed pages stay outside the default result dataset. The SDK charges the default dataset-item event once per saved result when Pay Per Event is enabled. The Actor checks the remaining event allowance before page work and before output. No extra custom result event is added. Use a graceful abort to save the final summary. A forced stop can interrupt that write.

### Output example

This example uses a placeholder image URL. A real run returns an Apify file link.

```json
{
  "url": "https://example.com/",
  "finalUrl": "https://example.com/",
  "httpStatus": 200,
  "screenshotKey": "capture-26793fa92e5bc98f.png",
  "contentType": "image/png",
  "imageBytes": 70915,
  "capturedAt": "2026-10-25T03:12:40.579Z",
  "pageElapsedMs": 673,
  "networkBytes": 47071,
  "mode": "viewport",
  "width": 1280,
  "height": 720,
  "documentSize": {
    "width": 1280,
    "height": 775,
    "scrollY": 0
  },
  "layoutChangedDuringCapture": false,
  "croppedToViewport": true,
  "heightLimitReached": false,
  "scroll": {
    "steps": 0,
    "stopReason": "disabled"
  },
  "elapsedMs": 128,
  "screenshotUrl": "https://example.com/capture.png"
}
```

### Supported pages

Use public HTTP or HTTPS URLs on ports 80 or 443. Login details, private cookies, custom request headers, remote URL-list files, local addresses, and private network destinations are unsupported. The Actor does not solve CAPTCHAs. Sites can refuse access or return content that differs from a local browser.

The Actor captures the content the browser receives. An HTTP success and a PNG do not prove that a page is complete or that its content is correct. Inspect the image and the limit fields before using it in a report.

### Local development

```bash
npm ci
npm test
apify validate-schema
apify run
```

On macOS the tests use installed Google Chrome. The cloud image includes Chrome and Playwright. The browser tests use synthetic pages. No cloud run is needed for these tests.

# Actor input Schema

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

Enter one to 50 public HTTP or HTTPS page URLs. Remote URL-list sources are not supported.

## `mode` (type: `string`):

Capture the exact viewport or a page region with explicit height and scroll limits.

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

Wait for page load by default. The faster DOM option can capture before styles or images finish loading.

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

Viewport width in CSS pixels.

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

Exact image height in viewport mode. Also sets the browser viewport in page mode.

## `maxHeight` (type: `integer`):

Maximum page-capture height in pixels. Used in page mode only.

## `maxScrollSteps` (type: `integer`):

Maximum scroll steps in page mode. The image returns to the top before capture.

## `scrollBudgetMs` (type: `integer`):

Maximum scrolling time in milliseconds. This does not include image capture.

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

Maximum seconds to load each page.

## `captureTimeoutSecs` (type: `integer`):

Maximum seconds for layout readiness, scrolling, and PNG capture after navigation.

## `pageTimeoutSecs` (type: `integer`):

Maximum seconds for page setup, navigation, and capture together. Storage is separate.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://example.com/"
    }
  ],
  "mode": "viewport",
  "waitUntil": "load",
  "width": 1280,
  "height": 720,
  "maxHeight": 8000,
  "maxScrollSteps": 12,
  "scrollBudgetMs": 1500,
  "navigationTimeoutSecs": 10,
  "captureTimeoutSecs": 10,
  "pageTimeoutSecs": 20
}
```

# Actor output Schema

## `captures` (type: `string`):

No description

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

No description

# 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/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_cleric/money-venture-website-screenshots").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/" }] }

# Run the Actor and wait for it to finish
run = client.actor("jungle_cleric/money-venture-website-screenshots").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": [
    {
      "url": "https://example.com/"
    }
  ]
}' |
apify call jungle_cleric/money-venture-website-screenshots --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_cleric/money-venture-website-screenshots"
        }
    }
}
```

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/KcMQnBsLVTFHE1dp6/builds/eO5lkhTIvexPxxs48/openapi.json