How to use ScreenshotOne in Make.com workflows

To use ScreenshotOne in Make, choose either a community-developed ScreenshotOne app or Make’s HTTP module calling ScreenshotOne’s HTTPS API. The community app gives you a visual module flow; a direct API request is useful when the app does not expose an option you need. ScreenshotOne says it does not currently have an official Make integration, and Make says it does not maintain or support the community app. Check the current listing and developer documentation before building a production scenario. ScreenshotOne’s Make guide · Make’s ScreenshotOne by Synergetic documentation.

1. Choose the integration route

Route	Use it when	What to check
Community ScreenshotOne app	You want a visual module for a website screenshot, scrolling or animated screenshot, or custom API call.	Confirm the app developer, module options, connection fields, and support channel in the live Make listing. The community app is not maintained or supported by Make.
Make HTTP module	You need to construct the request yourself or the community module does not expose a required API option.	Use HTTPS, keep the access key in a secure connection or credential field when available, and inspect the current HTTP module’s response settings.

Make lists community-developed ScreenshotOne apps, including an app by Synergetic. Its documentation describes API-key authentication and requires a ScreenshotOne account and access key. The available actions and exact input and output fields can vary by app version. Make directs users to the app developer for support. Make’s live app directory · Synergetic app documentation.

2. Set up the community app

Sign in to your ScreenshotOne account and obtain an access key. Use your account’s current key page; do not rely on a guessed dashboard menu name. ScreenshotOne API key instructions.
In Make, open the ScreenshotOne community app listing and select the app you intend to use. Read its current documentation and check who develops and supports it.
Add a ScreenshotOne module to a scenario and create a connection. Enter the credentials the selected app requests. The Synergetic documentation describes API-key authentication; other community apps may request additional credentials or use different terms.
Select the action that matches the output: a static website screenshot for a point-in-time image, a scrolling or animated capture for a longer page, or a custom API call where available.
Run the module once with a test URL. Inspect the returned data in Make’s execution details, then map the actual image or file output into the next module. Field names are app-version specific, so use the live output rather than assuming a particular property name.

ScreenshotOne’s integration catalog also describes Make use cases for HTML or Markdown rendered as images, PDFs, scrolling screenshots, and videos. The catalog describes service capabilities; verify which of them the selected community module exposes before designing around a particular action. ScreenshotOne integrations.

3. Call the API directly with Make HTTP

ScreenshotOne documents this GET request shape: https://api.screenshotone.com/take?url=https://apple.com&access_key=<access key>. It supports GET and POST and instructs clients to use HTTPS. HTTP is retained for legacy integrations, but ScreenshotOne says HTTP support will be disabled in the future. Getting started with ScreenshotOne.

Add Make’s HTTP request module to the scenario and configure a GET request to https://api.screenshotone.com/take.
Add query parameters for url and access_key. Map the target URL from the preceding module when it is dynamic. Use Make’s parameter fields so values are URL encoded correctly.
Set the response handling to retain the response body as a file or binary output, if the current HTTP module offers that option. ScreenshotOne returns image data for an image request; pass that binary/file output to the next module rather than mapping it as ordinary text.
Run the scenario with a simple public page. Inspect the status, response headers, content type, and output before connecting it to storage or another destination.
Map the returned file data to the receiving module. If that module asks for a filename or MIME type, use values appropriate to the format you requested and verify the fields in the actual response.

The exact Make HTTP module labels and binary mapping depend on the current Make interface. The API request and response format are the stable part to validate; do not assume a particular field name or output shape in a community connector.

4. Runnable API examples

These examples make the equivalent direct API request outside Make. They are useful for checking credentials, URL encoding, and whether the API returns an image before troubleshooting scenario mappings. Store keys as secrets in your shell or runtime rather than committing them to source control. Use ScreenshotOne’s current options reference for supported capture parameters.

cURL

curl -G "https://api.screenshotone.com/take" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "access_key=$SCREENSHOTONE_ACCESS_KEY" \
  -o screenshot.png

Python

import os
import requests

response = requests.get(
    "https://api.screenshotone.com/take",
    params={
        "url": "https://example.com",
        "access_key": os.environ["SCREENSHOTONE_ACCESS_KEY"],
    },
    timeout=90,
)
response.raise_for_status()
with open("screenshot.png", "wb") as image_file:
    image_file.write(response.content)

Node.js

const params = new URLSearchParams({
  url: 'https://example.com',
  access_key: process.env.SCREENSHOTONE_ACCESS_KEY,
});

const response = await fetch(
  `https://api.screenshotone.com/take?${params}`,
  { signal: AbortSignal.timeout(90_000) }
);
if (!response.ok) {
  throw new Error(`ScreenshotOne returned HTTP ${response.status}`);
}
const bytes = new Uint8Array(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('screenshot.png', bytes));

5. Handle the image in the rest of the scenario

A screenshot response is file content, not a text value containing an image. In Make, inspect a successful execution and map the returned file/binary data into the next module. The precise property labels depend on the selected app and module. For a direct HTTP request, configure the module to preserve the body as file data if that option is available.

Save or upload: map the file data to the destination’s upload field and provide a filename if required.
Store a reference: keep the destination file ID or URL in a data store or record if later scenario steps need it.
Process many URLs: iterate over input records and map one URL per capture action. Confirm the module’s current bundling, rate, and execution behavior before scaling up.
Keep binary intact: avoid converting the response body to text or logging the full body. Image bytes can be large and are not useful in a text log.

6. Security, reliability, and cost considerations

Protect credentials and page data

Use HTTPS for API calls. ScreenshotOne warns that HTTP does not encrypt requests and can expose access keys and other sensitive request data in transit.
Put the access key in a Make connection or secure credential facility where available. Do not paste real keys into public scenario screenshots, shared blueprints, or logs.
Check the community developer’s terms and support policy. Make’s documentation says it does not maintain or support the community integration. The Make listing describes the app as community developed.
Consider what URLs and page contents the scenario sends to the screenshot provider and subsequent storage or processing modules, particularly for private or authenticated pages.

Make failures recoverable

Run a representative URL through the capture and destination steps before scheduling the scenario. Inspect execution details when a step fails; a successful request alone does not prove that the receiving module got a usable file. For transient failures, use the retry or error-handling features currently available in Make, and ensure retries do not create unwanted duplicate uploads or records. The sources do not define a universal retry policy or a fixed response mapping for every community app.

Plan for latency and usage

Screenshot generation requires the target page to load and render, so page complexity and network conditions can affect how long a scenario step takes. Full-page or scrolling captures may involve more page content than viewport captures. Start with the smallest capture that satisfies the workflow and use the capture options documented for the API or exposed by the chosen module. Estimate total usage from the number of URLs processed and how often the scenario runs; the research sources do not establish a general price or benchmark for this Make workflow.

7. Troubleshooting

Symptom	Likely cause	What to do
Connection rejected or unauthorized	The key is missing, mistyped, belongs to a different account or organization, or the community app expects another credential.	Copy the current ScreenshotOne access key from the account and re-enter it in the connection. Check the chosen app’s live credential instructions. Do not share the key in a support screenshot.
HTTP call returns an API error instead of an image	Invalid option, missing URL or key, or an account/usage limit response.	Read the HTTP status and JSON error body, then correct the reported input or account issue. ScreenshotOne documents JSON error responses with an error code, message, and HTTP status. API error behavior.
Output appears as text or cannot be uploaded	The response was handled as text rather than binary/file data, or the next module expects a different input shape.	Configure response handling for a file where available; inspect the successful execution output and map its actual file data field into the destination.
URL with query parameters fails	The URL was not encoded correctly or was split across request parameters.	Map the URL through Make’s query-parameter input rather than manually concatenating a query string. In code, use URL parameter utilities such as `--data-urlencode` or `URLSearchParams`.
The capture is incomplete or the page looks different	The page may load content dynamically, require more time, or need a scrolling/full-page capture action.	Check the current ScreenshotOne options and the community module’s exposed controls. Test the required capture mode and wait behavior against the page before scheduling the scenario.
Make has no expected module or option	The selected community app version may not expose that API capability.	Check the live app documentation and developer support channel. Use Make’s HTTP module with the documented HTTPS API when you need a supported request shape not exposed by the connector.
Make support cannot resolve an app issue	The ScreenshotOne integration is community developed.	Contact the app developer listed in Make’s documentation or use the developer’s support channel. Make states it does not maintain or support the community integration.

8. Or skip the browser setup

If you would rather send one API request than maintain a Make capture module or browser workflow, ScreenshotNeo accepts a URL and returns an image or PDF. It is a website screenshot API and MCP server for developers. Here is the direct cURL call; see the ScreenshotNeo API documentation for request options.

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, newsletter popups, and chat widgets before capture. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents use screenshot tools. The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots. ScreenshotNeo also supports PNG, JPEG, WebP, and PDF, with capture options documented on its site. Learn about ScreenshotNeo.

FAQ

Is there an official ScreenshotOne app for Make?

ScreenshotOne’s Make guide says there is no official integration yet. Make lists community-developed ScreenshotOne apps.

Who supports the Synergetic app?

The app is community developed. Make says it does not maintain or support it; consult the current app listing for the developer’s support channel.

Can I use POST instead of GET?

Yes. ScreenshotOne documents both GET and POST. For POST, send options as JSON to the API endpoint; follow the current API documentation for the request body and options.

Can I use the captured image in another Make module?

Yes. Map the module’s returned file or binary data to a module that accepts a file, and verify the actual output fields in a test execution.