How to Use ScreenshotAPI.net with Zapier to Capture Web Pages

To capture web pages with ScreenshotAPI.net in Zapier, have a Zap supply the target page URL and your ScreenshotAPI.net token to the screenshot service, then pass the returned result to a later Zap step. ScreenshotAPI.net lists Zapier among its integrations, and its documented screenshot endpoint accepts a token and URL. The official material reviewed here does not establish the exact current Zapier trigger or action labels, or guarantee a particular response field, so confirm those details in the live Zapier editor and inspect a test run before mapping the result.

The documented endpoint is https://shot.screenshotapi.net/v3/screenshot. ScreenshotAPI.net also shows an older unversioned endpoint in some getting-started material. Use the endpoint and parameter names in its current docs or live integration, rather than mixing examples from different versions. ScreenshotAPI.net’s help page documents the versioned endpoint and the token and url parameters.

1. Prepare the trigger and capture inputs

Choose the event that starts the Zap. It might be a new record, a submitted form, or another event that contains a page address. The exact trigger depends on your source app.
Make sure the trigger provides a complete URL. Use an absolute URL such as https://example.com/article, not a domain fragment or a relative path. The service documents HTTPS URLs as required.
Get your ScreenshotAPI.net token. The vendor’s help page says the API key is available in the account dashboard. Treat it as a secret.
Choose what the next Zap step needs. Decide whether you need a normal viewport or full-page capture, and whether the downstream action expects an image or PDF. ScreenshotAPI.net documents multiple output and rendering options; exact parameter names and supported values should be checked in the current API docs.

Do not put a real token in a public code sample, a shared document, or a URL field that is visible to people who should not have access to it. Store credentials in Zapier’s designated authentication or secret fields where available. If the token is exposed, ScreenshotAPI.net says you can roll it in the dashboard; rolling it issues a new key and revokes the old one.

2. Configure the Zapier capture action

In Zapier, add the ScreenshotAPI.net integration/action if it is available in your account, or use a generic HTTP request step if your workflow requires it. The vendor lists Zapier as an integration, but the reviewed official pages do not confirm current editor labels or field mappings. Verify the live step’s required fields rather than relying on a guessed click-by-click guide.

At a minimum, the request needs the current screenshot endpoint, the token, and the URL value from the trigger. Add only the options your workflow needs. If the step lets you choose query parameters, set each parameter separately so Zapier can encode the target URL correctly. If you are using a raw URL field, ensure the nested page URL is percent-encoded; otherwise query characters such as & can be mistaken for API parameters.

Decision	What to check
Endpoint	Use the current documented version, presently shown as `/v3/screenshot`; do not assume older unversioned examples are interchangeable.
Credentials	The request parameter is named `token` in the documented endpoint. Keep its value secret.
Target	Map the trigger’s full HTTPS page URL into the case-sensitive `url` parameter.
Capture size	Choose viewport or full page according to what the recipient needs. Long pages and lazy-loaded content may need suitable rendering or delay settings.
Output	Run a test and inspect the actual returned fields. Determine whether your current action provides file data, a URL, or another representation before mapping it downstream.

3. Test the response and map it forward

Run the capture step with a known public page first. This isolates API configuration from trigger data problems.
Open the test result and inspect every returned field. Identify which one represents the screenshot or PDF in this particular integration setup.
Add the next action, such as storing or sharing the capture, and map the verified result field into it.
Test the entire Zap from trigger through the final action. Confirm that the captured page corresponds to the triggering URL and that the downstream app receives a usable file or link.
Turn the Zap on only after checking a representative page and any sensitive-data handling requirements.

Do not assume that the API’s response shape is identical across Zapier actions or configurations. The source material does not establish one universal output mapping. A test run is the reliable way to see what your live step returns.

4. Make a direct API request to validate configuration

If the Zap fails, isolate the API request outside Zapier. These examples show the documented endpoint and basic inputs. Check the current ScreenshotAPI.net docs for response behavior and optional parameter names before adapting them. The API may return a rendered image response or other result according to its endpoint behavior; these minimal examples save the response body for inspection.

cURL

curl --get 'https://shot.screenshotapi.net/v3/screenshot' \
  --data-urlencode 'token=YOUR_SCREENSHOTAPI_TOKEN' \
  --data-urlencode 'url=https://example.com/' \
  --output screenshot-response

Python

import os
import requests

endpoint = "https://shot.screenshotapi.net/v3/screenshot"
params = {
    "token": os.environ["SCREENSHOTAPI_TOKEN"],
    "url": "https://example.com/",
}

response = requests.get(endpoint, params=params, timeout=120)
response.raise_for_status()
with open("screenshot-response", "wb") as output:
    output.write(response.content)

print("HTTP status:", response.status_code)
print("Content-Type:", response.headers.get("content-type"))

Set the environment variable before running the script, for example with export SCREENSHOTAPI_TOKEN='your-token' in a local shell. The filename is intentionally generic: inspect the content type and current endpoint documentation before treating the response as a particular file format.

Node.js

const endpoint = new URL("https://shot.screenshotapi.net/v3/screenshot");
endpoint.searchParams.set("token", process.env.SCREENSHOTAPI_TOKEN);
endpoint.searchParams.set("url", "https://example.com/");

const response = await fetch(endpoint);
if (!response.ok) {
  const detail = await response.text();
  throw new Error(`Screenshot request failed (${response.status}): ${detail}`);
}

const bytes = Buffer.from(await response.arrayBuffer());
await import("node:fs/promises").then(({ writeFile }) =>
  writeFile("screenshot-response", bytes)
);
console.log("Content-Type:", response.headers.get("content-type"));

These examples use a 120-second Python timeout and the default fetch behavior in Node.js; adjust timeouts to your execution environment and the service’s current guidance. Do not log the full request URL when it contains the token.

5. Select capture options for the destination

Keep the first workflow simple, then add options only when the test image shows a specific need. ScreenshotAPI.net’s documentation describes image and PDF outputs, full-page capture, refresh behavior, delay/render controls, and other options. The exact parameter names and accepted values can vary by endpoint version; consult the current ScreenshotAPI.net documentation for your chosen endpoint.

Viewport or full page: Use viewport output for a fixed preview; use full-page capture when the complete document matters. Very tall pages can produce large files and longer jobs.
Image or PDF: Choose an image for previews and visual checks; use PDF when the destination is a document workflow. Confirm the Zap step can accept the resulting representation.
Fresh or cached: The getting-started documentation describes fresh=true for requesting a current screenshot instead of reusing a cached result. Use fresh rendering when page changes must be reflected, and verify the option remains supported by the endpoint you call.
Dynamic content: Single-page apps and lazy-loaded content may need a render delay or another supported wait option. Tune it against the actual target rather than choosing a long delay by default.
Cookie banners and ads: The vendor help page documents no_cookie_banners=true and block_ads=true. Check the current docs and test that the resulting capture is suitable.
Authenticated pages: ScreenshotAPI.net documents custom cookies and saved cookie templates. Use only credentials for pages you are authorized to access, store them as secrets, and do not expose them in Zap history or logs.

6. Reliability, performance, and cost

A screenshot is a browser render, so the target page’s load time, scripts, network dependencies, and content size affect how long the automation takes. Start with one URL, then test slow pages, redirecting pages, and pages whose content appears after load. Use the shortest wait behavior that consistently captures the required content. If a downstream step cannot consume the response immediately, inspect whether the configured integration returns a file, link, or other value and adapt that step accordingly.

For reliability, avoid firing many captures at once without checking your plan’s limits. ScreenshotAPI.net’s help page currently states a rate range of 20 to 80 requests per minute depending on subscription, but plan limits and terms can change. Add pacing or controlled retries in Zapier when appropriate, and avoid retrying permanent errors such as a missing URL or invalid token. For transient timeouts, use a bounded retry policy so one failing page does not create an uncontrolled loop.

ScreenshotAPI.net’s help page says failed renders do not count against plan usage and cached screenshots do not count as new usage, but usage definitions and plan terms should be checked directly before budgeting. The same help content describes a free trial and plan quotas; offers and prices change, so review the current pricing page before estimating recurring cost. Set an expected monthly capture volume and account for fresh renders, distinct URLs or options, retries, and any Zapier task usage in your own plan.

7. Troubleshooting

Symptom	Likely cause	What to do
`url_required` or HTTP 400	The URL field is missing, misnamed, not mapped, or not an HTTPS absolute URL. The parameter name is case-sensitive.	Check that the request uses `url` exactly and that the trigger field contains the complete URL beginning with `https://`.
Authentication error	The token is absent, mistyped, revoked, or placed in the wrong field.	Confirm the `token` parameter and dashboard key. If the key was rolled, update the Zapier connection or secret with the new key.
Zapier reports success but the next action has no image	The output field was assumed instead of inspected, or the destination expects a file while the action supplies a URL (or the reverse).	Open the capture test data, identify the actual output type, and map the matching value. Test the following action independently.
Request appears to use the wrong page URL	The nested URL was not encoded, or its query-string ampersands were parsed as API parameters.	Use separate query parameter fields or a URL builder that encodes values. In direct code, use URL/query parameter helpers or cURL’s `--data-urlencode`.
Screenshot is stale	A cached result may have been reused.	For a current capture, check whether `fresh=true` is supported by the endpoint version and set it when needed.
Screenshot misses content loaded later	The page renders after the capture point, or lazy-loaded content has not entered the viewport.	Use a documented delay or render option, test the actual page, and choose full-page behavior if the content extends below the viewport.
Cookie banner, ad, or chat overlay covers content	The page’s overlay remains visible in the rendered browser.	Check the vendor’s current options for cookie-banner removal or ad blocking, and verify the tested output. A site-specific popup may need a different supported option or custom handling.
Authenticated page shows a login screen	The render request has no valid session context, or the page uses a different authentication flow.	Use an authorized session cookie or supported authentication configuration. Keep session values secret and confirm they are not written into Zap task logs.
`screenshot_limit_reached` or HTTP 403	The account has reached its screenshot allowance.	Review account usage and current plan terms, reduce unnecessary fresh or duplicate captures, or choose a plan with sufficient quota.
`invalid_clipped_area` or HTTP 400	A requested clipping region exceeds the page bounds or has invalid coordinates.	Check clipping dimensions and coordinates against the page and remove clipping if it is not needed.
`Invalid_geolocation_parameter` or HTTP 400	Latitude or longitude is outside accepted bounds.	Use latitude from -90 to 90 and longitude from -180 to 180, as the vendor help page specifies.
Zap run times out	The target page is slow, unusually long, or waiting too long for content.	Test the request directly, reduce unnecessary waits, and check the execution limits of both Zapier and the screenshot service. For consistently slow pages, consider a workflow designed for asynchronous completion if the integration supports it.

For errors not listed here, capture the HTTP status and sanitized response detail from a direct request, then compare the endpoint and parameters with the current vendor documentation. Remove tokens, cookies, and private page URLs before sharing logs.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. One GET request takes a page URL and returns a PNG, JPEG, WebP, or PDF. The call below requests a WebP screenshot; see the ScreenshotNeo API documentation for the available parameters and formats.

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

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed; response headers say which result occurred and whether it was billed. An MCP server lets AI agents use screenshot tools. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000. Sign up for ScreenshotNeo’s free plan.

FAQ

Does Zapier have a native ScreenshotAPI.net action?

ScreenshotAPI.net lists Zapier as an integration, but the official pages reviewed for this guide do not verify the current action name or its field mapping. Check the app directory and your Zapier editor for the current integration in your account.

Can I capture any webpage?

You can request public pages and pages for which you have an authorized session. A site may still block automated access or require a session that the request does not provide.

Can I capture a PDF instead of an image?

ScreenshotAPI.net documents PDF among its output formats. Confirm the current endpoint’s format option and make sure the Zapier destination accepts the returned PDF representation.

Will one Zap run always use one screenshot credit?

Do not assume a one-to-one count. The vendor’s help page describes usage in terms of successful and unique/fresh renders, while exact billing depends on current plan terms and request options. Verify those terms for your account.