To take a website screenshot in a Make scenario, send the page URL to a screenshot API with Make’s HTTP Make a request module, then route the returned image or file to the next step. The endpoint, authentication, request fields, and response format depend on the provider; there is no single universal screenshot API request.
Choose how Make will connect to the screenshot API
There are two practical routes: use a provider-specific Make app when one is available, or call the provider’s API with Make’s HTTP app. Make describes HTTP as a way to connect to API services that do not have a native Make integration. Its documented modules include Make a request, Download a file, and Resolve URL. The request module supports HTTP methods, headers, query parameters, and different body types, along with API key, Basic Auth, and OAuth 2.0 authentication choices. Make HTTP app documentation
| Route | When it fits | What to check |
|---|---|---|
| Make HTTP app | The provider has no suitable native Make app, or you need to call a particular API endpoint. | Configure the provider’s endpoint, method, authentication, parameters, and response handling. |
| ScreenshotOne Make app | You want to use the listed ScreenshotOne-specific modules within Make. | Make describes this app as community-developed and notes that developer terms or fees may apply. Verify current availability, module fields, support, and fees. |
Make’s app listing for ScreenshotOne names Take a static screenshot, Take an animated screenshot, and Make an API Call. ScreenshotOne Make app listing The native app may reduce manual request setup; HTTP gives you a general route for other providers and endpoints.
Build a basic screenshot scenario with Make’s HTTP module
The example below uses ScreenshotOne’s documented /take endpoint. It is an example of one provider’s API contract, not a template that will work unchanged with every screenshot service. ScreenshotOne documents both GET and POST requests and recommends HTTPS. ScreenshotOne getting started
#1 Best Overall
- Choose a trigger. Start with the Make event that should initiate a capture. A custom webhook can act as an instant trigger that receives a request; alternatively, use an app trigger that supplies the page URL. Make webhooks documentation
- Add the request module. In the scenario, add HTTP > Make a request. Set the provider’s HTTPS endpoint and the HTTP method it documents. For ScreenshotOne’s GET example, the endpoint is
https://api.screenshotone.com/take. - Map the target page URL. Add the required screenshot parameter or JSON field and map the URL arriving from your trigger. ScreenshotOne’s getting-started example uses a target
urland anaccess_key. - Set authentication and options. Follow the provider’s instructions for sending credentials and screenshot options. Add only the options required for your use case, such as the desired output format. Keep secrets out of public scenario screenshots and logs.
- Run the module once. Inspect the actual response Make receives, then map it into the next scenario module. Do not assume the result is a public image URL: ScreenshotOne documents binary image data for its standard response, and the next step depends on the receiving app’s accepted input.
- Choose an error path. Decide whether a failed capture should stop the scenario or go to a review or recovery route. Make provides a setting to return an error when an HTTP request returns a 4xx or 5xx status; ScreenshotOne documents HTTP status codes and JSON error details.
GET versus POST
For a small request, a GET call can put the page URL and other supported options in query parameters. For ScreenshotOne, a documented POST approach sends screenshot options in a JSON body. The provider’s current API documentation determines which method and fields are valid. ScreenshotOne getting started
Keep credentials private
Make advises storing secrets in its dedicated Credentials field rather than putting them in headers or query parameters. Use that control where it supports the authentication method your provider requires. Providers can differ: ScreenshotOne documents access-key authentication through a query parameter, POST body, or the X-Access-Key header. Follow the provider’s current directions and Make’s available credential options rather than moving a key into an unsupported field. Make HTTP app documentation ScreenshotOne access-key guide
Do not publish a real API key in a scenario screenshot or a shared URL. ScreenshotOne warns that exposed keys should be replaced and that unsigned public screenshot URLs can expose keys. If a key is disclosed, replace it according to the provider’s instructions.
Handle the response and pass the image to another app
A successful API call does not guarantee that Make will receive a URL that another module can fetch. The API might return binary image data, a file-like output, JSON containing a URL, or another provider-specific response. Inspect the response from a successful module run before configuring the destination.
Free tools Windows power users keep installed
One-click scans. No signup required.
- Binary image response: Connect the returned data to a destination that accepts a file or binary content. If a file needs to be fetched separately, Make’s Download a file module may be relevant, but only when you have a URL that module can download.
- Hosted image URL: Map that URL into a destination field that expects a URL, or use a download step if the destination requires the actual file.
- JSON response: Identify the image or file field in the response and map that specific field. Do not map the entire JSON object as though it were image data.
- Non-image result or error: Check the HTTP status and response body before sending anything to a storage, publishing, or notification module.
ScreenshotOne’s API documentation describes binary responses for output formats such as PNG, JPEG, WebP, and PDF, and JSON for relevant response options. It also documents URL, HTML, or Markdown input. Those behaviors and supported formats belong to ScreenshotOne’s API; verify the response contract of whichever provider you use. ScreenshotOne API documentation
Rank #2
- Book - powershell for sysadmins: workflow automation made easy
- Language: english
- Binding: paperback
Pick the screenshot options your workflow needs
Keep the first scenario simple: capture the URL and confirm that the result reaches its destination. Then add provider-supported options for the page, output format, or capture behavior. ScreenshotOne’s endpoint documentation covers options and formats including PNG, JPEG, WebP, PDF, and text-oriented outputs. Other APIs may use different option names or offer a different set of formats. ScreenshotOne API documentation
When adding an option, verify three things in the provider’s documentation: the accepted field name and value, whether it belongs in the query string or request body, and whether it changes the response type. The last point matters because changing from an image response to JSON, PDF, or text can change how the next Make module must handle the result.
Where ScreenshotNeo fits
If you are choosing a screenshot API for this workflow, ScreenshotNeo is worth trying first: it removes cookie banners, popups, and chat widgets before capture, bills only clean shots, and its paid plan starts at $5 for 3,000 shots.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchOr skip the browser setup
Instead of assembling a browser-based capture service yourself, call ScreenshotNeo’s API from an HTTP request. Its one-call GET endpoint returns a screenshot or PDF. The following cURL example saves a WebP image:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpIn Make, configure an HTTP request to https://api.screenshotneo.com/v1/shot, send the access key and mapped target URL as parameters, and inspect the returned file data before mapping it to your destination. For exact request details and additional parameters, see the ScreenshotNeo API documentation.
- Cookie banners and consent notices, newsletter popups, and chat widgets are removed before capture; each step can be turned off.
- Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Responses identify the page verdict and billing status in headers.
- An MCP server offers AI agents tools for screenshots, page information, and PDF capture.
- The Free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000.
Sign up for ScreenshotNeo’s free plan to get 1,000 screenshots a month with no card.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshoot common Make screenshot failures
The request is rejected or returns an authentication error
Check the provider’s required credential method and exact parameter or header name. An access key placed in the wrong location can fail even when the key itself is valid. Store credentials in Make’s credential controls where compatible, and verify that the scenario is using the intended credential.
The API responds with a 4xx status
A 4xx response usually means the request was not accepted. Compare the endpoint, method, target URL field, authentication, and option names with the provider documentation. Read the response body for provider-specific error details instead of forwarding it as an image.
The API responds with a 5xx status or the scenario stops
Use Make’s HTTP error setting deliberately. A returned 5xx should take an error route or stop the scenario for review, according to your workflow’s needs; it should not be silently handled as a successful capture. If you retry, do so according to the provider’s retry guidance and your scenario’s limits.
The next module cannot accept the result
Inspect whether the successful response is binary, a file object, a URL, or JSON. Then match that shape to the destination. If the API returns binary data, a destination expecting a URL will not accept it as one; if it returns a URL, a file destination may require a download step.
The key appears in a public URL or shared scenario
Remove the exposed credential from shared material and replace it using the provider’s credential-management process. Avoid unsigned public screenshot links that contain a secret, and check scenario visibility before sharing.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Make does not show the expected ScreenshotOne module
Verify the app’s current availability and the module names in Make. The listing identifies the integration as community-developed and notes that terms or fees may apply, so its availability and conditions may differ from Make’s built-in HTTP app.
Plan for reliability, speed, and usage
Each screenshot adds an external API request to the scenario. Use a trigger that captures only the pages and events you need, and avoid sending unnecessary duplicate requests. Where the provider offers a cache or other reuse mechanism, check its documentation and decide whether a cached result is acceptable for the workflow.
For reliability, make the scenario distinguish a valid capture from an HTTP error and inspect the result before sending it downstream. Decide what should happen when a page fails to load or the provider returns an error: stop for review, notify someone, or follow a deliberate retry path. Do not assume that every provider has the same timeout, retry, caching, or billing behavior; check its current API terms and plan limits.
Before putting a scenario into regular use, test its full route with a representative page and the actual destination module. Confirm the output format, file handling, credential privacy, and failure behavior. A scenario that merely receives a successful API status is not complete until the intended file or URL reaches the next step.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
