Apify Screenshot Actor Pricing: What Do Runs and Storage Cost?

Short answer: The Apify Store listing for Multi-Resolution Website Screenshot, Actor ID incredible_moment/screenshot-actor, advertises a starting price of $1.50 per 1,000 screenshot sets. That “from” price does not establish your all-in cost for every configuration or run. Apify platform usage can also involve compute, data transfer, proxies, and storage operations, and your compute-unit rate depends on your subscription plan.

To estimate your actual bill, check the Actor’s current pricing panel, define what one set means for your chosen viewports and capture options, and inspect usage for a run on your account. The examples below show how to run this specific Actor; they do not claim a measured price or performance result.

1. Which Apify Screenshot Actor does this price refer to?

There are multiple similarly named screenshot Actors in the Store. The listing discussed here is Multi-Resolution Website Screenshot, published by incredible_moment. Its listing describes capturing mobile, tablet, and desktop viewports, with options for full-page captures, custom widths, and PNG or JPEG output. Do not apply this Actor’s advertised rate to another listing named “Screenshot Actor.”

The listed input options include a target URL, device viewports, custom widths, full-page capture, output format, JPEG quality, and a rendering wait. Listed defaults include mobile, tablet, and desktop enabled, full-page disabled, PNG output, JPEG quality 80, and a 2,000 ms wait. Confirm the live input form and pricing details before a production run because listing settings and prices can change.

2. What does “$1.50 per 1,000 screenshot sets” mean?

It is the Store listing’s advertised starting event rate. It is not enough information by itself to calculate a particular account’s total cost. The listing’s unit is a “screenshot set,” while the input can include multiple viewports and widths. Check the Actor’s live pricing panel to determine how its event definition applies to your selected configuration.

Cost component	What to verify
Actor event charge	The current listed price, what counts as one event or set, and any pricing conditions shown on the Actor page.
Compute	Run duration and allocated memory contribute to compute-unit usage; CU cost depends on your subscription plan.
Data transfer	Traffic between the browser, target websites, and Apify may contribute platform usage.
Proxy use	If proxies are involved in a workload, proxy usage can be a billed platform resource.
Storage operations	Dataset or other storage reads and writes can have usage charges, including post-run access operations.

Apify describes pay-per-event pricing as a fixed charge for events defined by the Actor creator, and pay-per-usage pricing as billing for platform resources. Consult the individual listing to see which model and inclusions apply. Do not assume the displayed “from” rate includes every platform charge unless the current pricing panel says so. See Apify’s Actor pricing and costs documentation and usage and resources documentation.

3. How can I estimate a run’s cost?

1. Record the live price and model. Open the Actor’s Pricing tab and note its current rate, billable unit, included usage, and any plan conditions.
2. Define one workload. Specify the number of URLs, enabled viewport types, custom widths, full-page setting, output format, and any wait configuration. A multi-viewport set is not necessarily comparable to a single screenshot from another service.
3. Run a representative sample. Use a small batch of representative pages. Include the kinds of page weight and rendering behavior you expect in production.
4. Inspect the run usage. In Apify Console, open the run and review its Usage details. Note compute, transfer, proxy use, and storage operations as applicable.
5. Estimate your target volume. Use the observed resource usage only for a workload sufficiently similar to the sample. Include expected reads or downloads after completion and your plan’s applicable rates.

A useful planning model is: estimated total = Actor event charges + compute usage + data-transfer usage + proxy usage + storage-operation usage. The live pricing panel and the run’s usage report determine which terms apply. Apify notes that run usage is visible in the Console; its documentation also explains that compute depends on memory and run duration.

Storage: what may be charged?

The Actor’s results are available through its run storage, including the default dataset. Apify Store guidance says reads or writes against a run’s dataset after the run completes can incur standard platform usage charges. Treat these as storage-operation charges; the available evidence does not establish a recurring storage subscription for this Actor. Apify also says unnamed datasets are automatically removed after the configured data-retention period. Check the retention behavior and current storage pricing for your account before depending on long-term availability.

Repeatedly fetching result data, fetching large outputs, or building a workflow that makes many storage API calls can change the operation count. Include that access pattern in your estimate rather than counting only the Actor run.

4. Run the Actor with the Apify API

You need an Apify account and an API token from the Integrations settings in Apify Console. Keep the token private; do not put it in browser-side code or commit it to a repository. The following examples submit a URL to the identified Actor.

cURL

export APIFY_TOKEN='YOUR_APIFY_TOKEN'
curl 'https://api.apify.com/v2/acts/incredible_moment~screenshot-actor/runs?token='"$APIFY_TOKEN" \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://example.com"}'

This starts a run and returns run metadata. For a synchronous request that waits for completion and returns dataset items, Apify exposes the run-sync-get-dataset-items endpoint; consult the Actor API page for endpoint behavior and response details.

Python

import os
import requests

api_token = os.environ["APIFY_TOKEN"]
endpoint = (
    "https://api.apify.com/v2/acts/"
    "incredible_moment~screenshot-actor/runs"
)
response = requests.post(
    endpoint,
    params={"token": api_token},
    json={"url": "https://example.com"},
    timeout=60,
)
response.raise_for_status()
run = response.json()
print("Run ID:", run["data"]["id"])
print("Status:", run["data"]["status"])

Node.js

const token = process.env.APIFY_TOKEN;
if (!token) throw new Error('Set APIFY_TOKEN first');

const endpoint = new URL(
  'https://api.apify.com/v2/acts/incredible_moment~screenshot-actor/runs'
);
endpoint.searchParams.set('token', token);

const response = await fetch(endpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ url: 'https://example.com' }),
});
if (!response.ok) {
  throw new Error(`Apify returned ${response.status}: ${await response.text()}`);
}
const result = await response.json();
console.log('Run ID:', result.data.id);
console.log('Status:', result.data.status);

For the full endpoint examples and input schema, see the Actor’s API page. Its input form is the authoritative place to confirm current option names and defaults.

5. What changes the cost of a screenshot set?

• Viewport count and widths: Confirm how the Actor defines a set when multiple viewports or custom widths are enabled. For price comparisons, count delivered images, not just input URLs.
• Full-page rendering: A longer or more resource-intensive page render can affect duration and therefore resource use. The dossier does not provide a measured cost difference for this option.
• Wait time and page behavior: The configured wait and the target page’s load behavior can affect how long a browser run occupies resources.
• Image format: PNG versus JPEG and JPEG quality affect the output configuration. Do not infer a specific transfer or storage savings without measuring your outputs.
• Batch size: The number of URLs affects total events and overall resource consumption. A batch’s actual profile depends on the pages and run configuration.
• Plan: Apify says compute-unit costs depend on subscription plan. Use your account’s rates rather than a rate from another plan.
• Post-run access: Dataset reads and writes after completion may add platform usage. Include how your application retrieves results.

6. Cost, performance, and reliability notes

Cost: The $1.50 per 1,000 sets is a useful listing-level starting point, not a guaranteed invoice total. The dossier does not establish all-in pricing for a particular configuration. Recheck the live Actor page and your plan before estimating volume.

Performance: No run was performed for this guide, so it makes no speed or cost benchmark claims. Browser rendering, page complexity, waits, and capture scope all belong in a representative sample. Apify’s resource documentation identifies browser work, run size and frequency, and page type as factors that can influence consumption.

Reliability: A successful API response when starting a run means the run was accepted; check its eventual run status and result data before treating screenshots as complete. For repeatable estimates, use a sample that reflects real URLs and inspect both run outcomes and usage. The Actor listing’s advertised price does not guarantee that every target website will render successfully.

7. Troubleshooting billing and run questions

Symptom	Likely cause	What to do
The bill is higher than 1.50 dollars per 1,000 sets.	The listing rate is a starting event price; platform usage, account plan, or post-run storage operations may also apply.	Check the live pricing panel, then open the run’s Usage details and review compute, transfer, proxy, and storage-operation usage.
The estimate differs from the billed amount.	The sample and production workloads may differ in page weight, duration, configuration, or result access pattern.	Compare input settings and run usage for the sample and production runs; repeat the sample with representative URLs.
You cannot tell what one “set” includes.	The unit is defined by the Actor’s pricing configuration, and multiple viewports or widths can produce multiple outputs.	Read the current Pricing tab and confirm its event definition. Ask the Actor maintainer if the listing does not make the unit clear.
Dataset access adds unexpected usage.	Reads or writes after run completion can incur platform usage charges.	Review how often your integration reads results and include those operations in your estimate.
The API returns an authorization error.	The token may be missing, invalid, or incorrectly passed.	Confirm the token in Apify Console Integrations, set APIFY_TOKEN, and ensure it is sent as the token query parameter. Keep it out of public client code.
The run starts but results are missing or incomplete.	The run may not have completed successfully, or the requested input may be invalid.	Inspect the run status and log in Console, then check the current Actor input schema and dataset. Do not infer successful capture from run creation alone.

8. ScreenshotNeo: an alternative to try first

If your main task is to request website screenshots through an API, ScreenshotNeo is a direct alternative: one GET request returns a PNG, JPEG, WebP, or PDF. It is a website screenshot API and MCP server from Yorker Media.

Its listed distinction is that cookie and consent banners, newsletter popups, and chat widgets are handled before capture, and bot checks, blank pages, and failed loads are not billed. Responses identify the page verdict and billing status in headers. AI agents can use its MCP server with the take_screenshot, get_page_info, and capture_pdf tools. Its free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. All listed features are available on every plan. See the ScreenshotNeo API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Equivalent Python request:

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

Equivalent Node.js request:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Try ScreenshotNeo free with 1,000 screenshots a month and no card.

9. FAQ

Is $1.50 the guaranteed total for 1,000 screenshot sets?

No. It is the listing’s advertised starting price. Check the Actor’s current pricing details and your account’s run usage to determine applicable charges.

Do I pay a monthly fee just to keep a run’s dataset?

The available guidance establishes that dataset reads or writes after a run may incur platform usage charges. It does not establish a recurring storage subscription for this Actor. Check the current retention settings and account pricing.

Can I compare this rate directly with another “per 1,000” screenshot price?

Only after checking the billable unit, included platform usage, capture scope, output and storage behavior, and your plan’s rates. A screenshot set with several viewport outputs may not match another provider’s single-image unit.

Where do I find the actual usage for my run?

In Apify Console, open the run from the Runs section and inspect its Usage details. Apify’s usage documentation describes the usage fields and compute units.