How to Use a Screenshot API in a Make.com Scenario

To use a screenshot API in a Make.com scenario, add the provider’s native Make app if it supports the capture you need. Otherwise add HTTP > Make a request, configure the provider’s documented endpoint, method, authentication, URL and capture options, then map the response into the next module. First check whether the response is binary image data, JSON, or a file URL: each needs different downstream handling.

There is no universal screenshot API endpoint or response format. The provider determines the request contract. Make’s HTTP app is designed to connect to API services without a Make integration. Make HTTP app documentation.

Choose a Make module

Route	Use it when	Check before building
Provider-specific Make app	It exposes the capture action and options your scenario needs.	Who maintains the connector, which inputs it supports, how it handles credentials, and whether the output is a file or URL.
HTTP > Make a request	There is no suitable app, or you need API options the app does not expose.	Provider endpoint, method, authentication, parameters, response format, and error behavior.

Make lists a GetScreenshot app identified as a verified app maintained by its official vendor. Its listed actions include full-page and element captures, usage lookup, and emailing captures. Make also lists a ScreenshotOne connector whose documentation labels it community developed; Make says it does not maintain or support that connector. Check the current listing and action inputs before choosing either app.

Build the scenario with HTTP

Add a trigger. Choose the event that supplies the page URL: for example, a form submission, webhook, schedule, or record from another app. A screenshot API does not require a particular trigger.
Add HTTP > Make a request. Enter the provider’s exact HTTPS endpoint and HTTP method. Configure authentication in the provider’s documented location and provide the target page URL.
Set capture options. Add only options supported by that API, such as image format or capture scope. Do not assume parameter names transfer between providers.
Run once and inspect the output. Identify whether the module returned binary file data, JSON, or a URL, and check the response status and headers when available.
Map the correct value downstream. Send binary file data to a module that accepts a file. Parse JSON or map its relevant field if the response is structured. If the response contains a usable download URL, use Make’s HTTP > Download a file before passing a file to a destination app.
Set failure handling. Make’s HTTP app can be configured to return an error when a request receives a 4xx or 5xx response. Decide whether the scenario should stop, route the failure for review, or retry where that is appropriate.

Make’s HTTP app also documents a Resolve URL action. It can be useful when a workflow needs to resolve a URL or redirect before its next step. See Make’s HTTP documentation for current module behavior and settings.

Concrete example: ScreenshotOne

The following request shape is specific to ScreenshotOne; it is not a universal screenshot API recipe. Its getting-started documentation uses a GET request to https://api.screenshotone.com/take with a target url and an access_key. It also documents POST requests with options in a JSON body. For a Make scenario, set the method and fields to match the request you choose in ScreenshotOne’s current documentation.

In the HTTP module, set the URL to https://api.screenshotone.com/take and the method to GET.
Provide url as the mapped target page URL and access_key using the provider’s supported authentication method.
Choose the response format and output behavior that suit the next module. ScreenshotOne documents PNG, JPEG, WebP, PDF, and other formats. Its default by_format response returns the selected representation as binary; other response modes behave differently.
Run the scenario and inspect the output. If it is binary, map the file data to the destination. If you chose a JSON or hosted-URL response, map the relevant JSON field or download the returned URL as a file.

ScreenshotOne says its access key is scoped to an organization and documents obtaining it from the account’s access page. Its documentation describes sending the key in a query string or a POST JSON body. Keep the key out of shared scenario URLs, public blueprints, and screenshots. Make recommends using its dedicated Credentials field rather than passing authentication details in headers or query parameters when the supported authentication setup applies. Follow both Make’s credential guidance and the provider’s API contract. Sources: ScreenshotOne getting started, ScreenshotOne options, ScreenshotOne API keys, and Make HTTP documentation.

Map the response to another app

Choose the downstream mapping from the actual response, not from the fact that the request was called a screenshot:

Response from capture request	Next step in Make	Common destination mapping
Binary image or PDF data	Map the file data directly if the destination accepts a file.	Use the destination’s file input and map the response file data and filename where required.
JSON containing metadata or a URL	Map the needed JSON field. If it is a file URL, add HTTP > Download a file.	Use the parsed URL or other relevant field; do not pass the entire JSON object as a file.
Plain URL or redirect	Resolve it if needed, then download the file when the destination expects file data.	Map the downloaded file output, not just the URL string.

Make documents Download a file for fetching a file from a URL. Whether you need it depends on the screenshot API’s response mode. See Make’s HTTP module documentation and, for the ScreenshotOne example, its response options.

Security, reliability, and cost

Protect API keys. Store credentials using Make’s supported credential handling where it fits the provider’s authentication contract. Avoid putting secrets into shared scenario blueprints, publicly visible URLs, or screenshots of module settings.
Handle API errors deliberately. Inspect non-success responses during setup. Configure Make’s 4xx/5xx error behavior so a failed capture does not silently flow into a module expecting an image.
Plan for output differences. Response formats can change with provider options. Confirm whether each route returns bytes, JSON, or a URL before relying on it in production.
Check current limits and charges. The research for this guide does not establish current provider quotas or prices. Confirm the selected provider’s terms and usage information before running high-volume scenarios.
Keep the scenario narrow. Request only the capture format and options you need, and map only the required output fields. This makes later changes to the capture service easier to diagnose.

Or skip the browser setup

ScreenshotNeo is a screenshot API and MCP server for developers. One GET request returns an image or PDF, and its parameter names are compatible with those used by other screenshot APIs. See the ScreenshotNeo API documentation for the request options and response details.

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}`);

Use the returned file in the next step of your workflow. ScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each of those steps can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers report the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for AI agents. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots.

Troubleshooting

Symptom	Likely cause	Fix
4xx response	Wrong endpoint or method, missing required field, malformed target URL, or rejected authentication.	Compare the request with the selected provider’s current API docs. Verify the HTTP method, full endpoint, required fields, URL encoding, and where the key belongs.
Authentication failure	The key is invalid, belongs to another account or organization, or is sent in the wrong place.	Confirm the key’s scope and configure it according to the provider’s authentication contract. For ScreenshotOne, the access key is organization scoped.
The next module rejects the result	The response is JSON or a URL, but the destination expects a file; or the response is binary and was mapped as text.	Inspect the preceding module output. Map binary data as a file, parse and map JSON fields, or use Download a file for a usable file URL.
5xx response or failed scenario	The API returned a server error, or Make is configured to stop on a 4xx/5xx response.	Inspect the error response, confirm the request is valid, and route or retry failures according to your workflow. Do not treat an error payload as an image.
Credential appears in a shared scenario	The key was entered in a field or URL that becomes visible in a blueprint or shared configuration.	Move it to Make’s supported credential storage where applicable, restrict scenario access, and replace an exposed key according to the provider’s account controls.
Downloaded file is not the expected image	The URL may return a redirect, JSON error, or a different format than the destination expects.	Check the response status, content type, and selected response mode. Resolve or download the actual file URL and confirm the destination supports the chosen format.

FAQ

Does a screenshot API require a particular Make trigger?

No. Use whichever trigger supplies the page URL and fits the workflow, such as a webhook, schedule, form, or another app.

Can I pass the screenshot directly to a storage or email module?

Yes, if the request module returns binary file data and the destination accepts that file input. For a JSON response or URL, map or download the file first as appropriate.

Is the ScreenshotOne request example valid for every screenshot service?

No. Its endpoint, key name, method, and response modes are specific to ScreenshotOne. Use the selected provider’s current API documentation for its request contract.

Which option should I use if a community connector is listed?

Check who maintains it, whether its actions expose the capture and output you need, and what support the listing describes. Make labels the ScreenshotOne connector community developed and says Make does not maintain or support it.