How to Use ScreenshotOne with Zapier to Capture Web Pages Automatically

To capture pages automatically with ScreenshotOne and Zapier, create a Zap with a trigger, add ScreenshotOne’s Take Website Screenshot action, map in the page URL, configure capture options, test the result, and send it to a destination app. Use a schedule trigger for recurring captures, or an upstream app or webhook when an event should start the capture. Choose the animated or scrolling action when a still image is not the output you need.

Choose the trigger and capture type

A Zap follows this pattern: trigger → ScreenshotOne capture → destination. The trigger decides when the capture runs; the ScreenshotOne action decides what to capture and how; the destination stores or processes the result.

Need	Trigger and action
Capture at a recurring interval	Choose a schedule trigger and set the desired frequency, then use Take Website Screenshot.
Capture when something happens in another app	Use that app’s trigger if it provides a page URL, then map the URL into Take Website Screenshot.
Start capture from an incoming event	Use a webhook trigger that supplies the target URL, then map that value into the ScreenshotOne action.
Capture motion or a scrolling sequence	Choose Render Animated or Scrolling Website Screenshot and configure its duration or scrolling settings as needed.

Zapier’s ScreenshotOne listing includes daily, hourly, and weekly schedule examples, and a webhook-triggered capture example. These are workflow patterns, not a guarantee that every account has the same trigger choices or limits. See the ScreenshotOne integration listing for the current actions and fields.

Set up the Zap

1. Create the Zap and select a trigger. For recurring monitoring, pick a schedule trigger and set its frequency. For event-based capture, choose the source app or a webhook that provides the URL. If the trigger emits a URL dynamically, use that value rather than typing a fixed URL.
2. Add ScreenshotOne as the action. Select Take Website Screenshot for a still image. Select Render Animated or Scrolling Website Screenshot when a moving or scroll-based capture is required.
3. Connect your ScreenshotOne account. Follow the account connection flow shown in the Zap editor. Keep credentials private; do not place access keys in a URL that will be stored in a shared document or exposed to an audience.
4. Set the target website URL. Map the trigger’s URL field, or enter a stable URL for a fixed recurring capture. Check that the mapped value includes the scheme, such as https://, and does not contain whitespace or a missing path.
5. Configure only the options the task needs. Start with output format and response type. Add full-page capture, a selector, viewport or device scale, mobile viewport, hidden elements, blocking, delay, timeout, wait-until, proxy, or IP country code as appropriate. For the animated/scrolling action, configure format, response type, video duration, scroll delay, scenario, viewport dimensions, hidden selectors, blocking, timing, and proxy as needed. The editor’s exact fields can change.
6. Test the action with an authorized page. Inspect the returned result and verify that the content, dimensions, and file or response form work for the next step. The listing establishes the actions and inputs; it does not guarantee that every destination app accepts the returned result in the same way.
7. Add the destination and map the result. Choose the next app, then map the image or response field the test produced into the destination’s appropriate input. For example, an Airtable record can follow a capture in an event-driven flow. Confirm whether the destination expects a file, URL, or another value before publishing.
8. Publish and monitor the workflow. Confirm the trigger frequency and the downstream action behavior in your accounts. For recurring captures, estimate the number of runs and review your current Zapier and ScreenshotOne account limits.

Configure capture options

The ScreenshotOne Zapier listing exposes options for still and animated/scrolling captures. Available controls may evolve, so use the fields currently shown in the editor and consult the provider’s documentation when a field’s accepted values are unclear.

Option group	When to use it	Practical guidance
URL	Every capture	Required. For event-driven Zaps, map the trigger value and verify it is a complete, authorized target URL.
Format and response type	Every action	Choose an image format and response form compatible with the next app. Test the mapped output before relying on it in a live Zap.
Full page, selector, viewport, device scale, mobile viewport	When the capture must cover a whole document, a particular element, or a defined screen/device layout	Use a selector for a specific region; use viewport settings when layout dimensions matter. Full-page output may be substantially larger than a viewport shot.
Hide selectors	When a specific element should not appear	Hide only the elements you intend to omit. Check the test image for layout shifts caused by removing page content.
Banner, ad, tracker, and chat blocking	When those elements are irrelevant to the capture	Enable only the relevant controls. Blocking can change what appears on the page, so inspect the resulting capture.
Delay, timeout, wait-until	When the page needs time or a load condition before capture	Use the smallest delay and timeout that reliably captures the needed content. A fixed wait may be inadequate for a slow page and waste time on a fast one.
Proxy and IP country code	When the page varies by network route or region	Set them only when the target and your authorization allow it. Regional and proxy-dependent pages can still show different content or block automated access.
Video duration, scroll delay, scenario	Animated or scrolling action	Choose these based on how much movement and page content the result should show; test that the captured sequence includes the intended section.

Use the ScreenshotOne API when the Zap action lacks an option

If the built-in action does not expose a parameter you need, Zapier lists an API Request action as a possible advanced route. Zapier describes that action as beta and intended for people comfortable with HTTP requests, APIs, and API documentation. Do not guess parameter names or encoding: check ScreenshotOne’s current API documentation and configure the request to match it.

ScreenshotOne documents GET requests with options in the query string and POST requests with JSON in the body. Its documented maximum POST body size is 100 MiB. Requests require an access_key; signing is optional and uses a signature derived from screenshot parameters and a signing key. Always use HTTPS, and treat both keys as credentials. See the getting started guide and options reference.

curl -X POST 'https://api.screenshotone.com/take' \
  -H 'Content-Type: application/json' \
  -d '{"access_key":"YOUR_ACCESS_KEY","url":"https://example.com"}' \
  -o screenshot.png

This is a generic API shape, not a replacement for the built-in Zap action’s tested field mapping. Match the body fields and response handling to the current API docs and the API Request action. Do not expose a real key in a shared Zap, logs, or public example.

Authenticated pages require special care. ScreenshotOne documents custom authentication headers and cookies as options for pages you are permitted to access. Use them only for pages you own or are authorized to capture; they do not guarantee access through a site’s controls or override its restrictions.

Or skip the browser setup

ScreenshotNeo provides a website screenshot API and MCP server. Its one-call API can return an image or PDF, and its parameter names also work with those used by other screenshot APIs to make switching easier. 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

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)

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

ScreenshotNeo accepts cookie or consent banners like a visitor, then removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and responses report page verdict and billing headers. Its MCP server offers take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, or any MCP client. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account and get 1,000 screenshots a month with no card.

Troubleshooting

Symptom	Likely cause	What to check
The URL is empty or invalid	The trigger did not provide the expected field, or the mapped value is not a complete URL.	Inspect the trigger test data, map the actual URL field, and check for a scheme such as https://.
The capture is blank or missing late-loading content	The page has not rendered the needed content when capture starts.	Try an appropriate wait-until condition or a modest delay, then test again. Check whether the content appears only after scrolling or interaction.
A full-page capture is too large or slow for the next step	The page is long or the destination has constraints on file size or input type.	Capture a selector or viewport instead, and confirm what form the destination accepts.
Cookie banner, chat, or ad appears in the shot	The relevant blocking option is disabled or the page uses a banner the action does not remove.	Review the action’s available blocking fields and test the result. Blocking behavior depends on the page and current integration options.
Animated result misses content	The selected duration, scroll delay, scenario, or viewport does not cover the intended page region.	Adjust those settings and inspect a test capture before enabling the workflow.
Authenticated page is still inaccessible	The site may reject the request or require session state not supplied to the capture.	For an authorized page, check its allowed authentication header or cookie configuration and the site’s access rules. Do not assume capture settings bypass access controls.
API Request step fails	The request may have incorrect query/body encoding, missing credentials, or a response mapping mismatch.	Compare it with ScreenshotOne’s current API docs, keep the request on HTTPS, and verify the API Request beta action’s inputs and returned fields.
Unexpected Zap runs or cost	The trigger frequency, retries, or account quotas may not match the expected volume.	Review task history, schedule settings, and current account plan limits. The reviewed integration information does not establish current prices or quotas.

Performance, reliability, and cost

Capture frequency multiplies usage: a schedule that runs more often creates more capture actions, and an event trigger can run once for every incoming event. Estimate expected runs over a billing period before publishing, and account for any downstream steps and retries. The reviewed sources do not establish current ScreenshotOne prices, quotas, or account-specific Zapier limits, so check both account plan pages rather than relying on an assumed monthly allowance.

For reliability, make the trigger supply a valid URL, use a wait condition suited to the page, and test the complete path through the destination. A fixed delay can help with content that appears late, but it also increases run time and may still fail when rendering time varies. For large or dynamic pages, start with the smallest capture scope that answers the monitoring question. Use API Request only when necessary and keep access credentials protected.

FAQ

Can Zapier capture a page on a schedule?

Yes. The ScreenshotOne integration listing shows schedule-based examples, including daily, hourly, and weekly patterns. Your available schedule and account limits depend on the current Zapier plan and editor.

Can a Zap capture a URL supplied by another app?

Yes, if the trigger provides the URL. Map that field into the ScreenshotOne action and test it with representative trigger data.

Which ScreenshotOne action should I choose?

Use Take Website Screenshot for a still image. Choose the animated or scrolling action when the result should show motion or a scrolling sequence.

Can I use this for a page behind a login?

ScreenshotOne documents headers and cookies for authorized access. Whether they work depends on the page’s authentication setup and access rules.