Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsFor a straightforward website screenshot in Make.com, add the HTML/CSS to Image → Create a Screenshot of a URL action, map in the page URL, then send its returned image to a storage, email, messaging, or database module. If the page needs browser interaction, authentication, or reliable JavaScript rendering, use a browser-automation integration instead. If you want to call a screenshot API, Make’s HTTP app can make the request and download the file, but it is not itself a documented webpage renderer.
Take a website screenshot with Make’s native action
This is the shortest route when you have a URL and want Make to capture the website without building a browser workflow. Make describes the HTML/CSS to Image action as taking a screenshot of any website.
- Choose a trigger. Start the scenario with the source of your URL: for example, a webhook, a spreadsheet row, a database record, or a schedule. The trigger should provide a URL for each run.
- Add the screenshot action. Add the HTML/CSS to Image → Create a Screenshot of a URL module to the scenario.
- Map the target URL. In the action’s URL input, select the URL value from the trigger. If the trigger contains multiple records or bundles, check that the mapped value belongs to the current one.
- Choose where the result goes. Add a destination module such as cloud storage, email, chat, or a database. Map the image returned by the screenshot action to the destination’s relevant file or attachment input. The exact input label depends on the destination app.
- Preserve context. Where the destination supports it, store the source URL and capture time with the image. This makes later review easier when a page changes or a capture needs investigation.
- Run one controlled execution. Inspect the resulting image and confirm the intended URL and destination before enabling a recurring schedule.
The module name and URL mapping are the core of the workflow. The remaining modules are ordinary scenario steps that route the capture to the place your team uses.
Or skip the browser setup
If you want a direct screenshot endpoint rather than configuring a browser automation workflow, ScreenshotNeo returns an image or PDF from one GET request. Its cookie-banner, popup, and chat-widget cleanup happens before capture; bot checks, blank pages, and failed loads are not billed; and its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Here is a cURL request for a WebP capture; replace the URL with the page you want to capture and supply your API key:
#1 Best Overall
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request options and response details. For a Make scenario, use Make’s HTTP app to call the endpoint with your key and URL, then route the returned file to a storage or delivery module. Keep the key in the HTTP module’s dedicated credentials configuration rather than exposing it in a public URL or scenario output.
Sign up for ScreenshotNeo free: 1,000 screenshots a month, no card required.
Choose a Make route for the page you need to capture
Use the simplest route that can render the page and produce the output you need. These options are integrations or workflow patterns documented for Make; the matrix does not imply a quota or guarantee of successful capture.
Recommended Free Tools
| Route | Best fit | What it provides |
|---|---|---|
| ScreenshotNeo | Calling a screenshot endpoint from a Make scenario | A single GET request returns a screenshot or PDF; clean shots are billed, with bot checks, blank pages, failed loads, timeouts, and cache hits not billed. |
| HTML/CSS to Image | Basic URL screenshots inside a Make scenario | A native Create a Screenshot of a URL action described as taking a screenshot of any website. |
| GetScreenshot | Element-level captures or email delivery | A verified Make app from Rasterwise with actions for screenshots, element screenshots, email delivery, API usage, and API calls. |
| Custom JS | Pages that need browser automation | Make documentation lists a browser-automation website screenshot module. It requires a Custom JS account and an API-key connection. |
| Anchor Browser Agent | Interactive browser sessions | Chromium screenshots alongside navigation, clicking, typing, and session modules. Its public documentation is limited. |
| Make HTTP | Calling an external screenshot endpoint or downloading a result | HTTP request, download, and URL-resolution modules. HTTP is a transport and download route, not a documented screenshot renderer on its own. |
Capture a page element or deliver a screenshot by email
If you need a screenshot of one element rather than a URL-level capture, use the separate GetScreenshot Make app and its Take Element Screenshot action. The action requires an element selector. GetScreenshot is marked as a verified app in Make, and Make identifies Rasterwise as its official vendor.
GetScreenshot also lists Take Screenshot, email-delivery variants for full-page and element captures, Get API Usage, and Make an API Call. Make describes scheduled captures, saving to cloud storage, and team sharing as workflow patterns for the app; check the app and your account for current availability and terms rather than assuming a particular quota or plan.
Handle JavaScript-heavy or interactive pages
A page can look different in a browser than it does in a basic HTTP response. JavaScript may build the page after load, and the content you need may appear only after a click, sign-in, or other interaction. A plain HTTP request can retrieve HTML without running the same browser behaviors as a real Chromium session.
For those cases, Make’s Custom JS documentation lists Take Website Screenshots via Browser Automation. The documented setup requires a Custom JS account, an API key, adding a Custom JS module, and creating a connection with that key. If the workflow must navigate, click, type, or maintain a browser session, Anchor Browser Agent is another Make integration with Chromium screenshots and interaction modules; its public documentation is limited, so verify the supported session steps for your use case.
Call an external screenshot API with Make HTTP
Use Make HTTP when a service already provides a screenshot endpoint. The scenario sends the request to that service and routes its response; the external service is responsible for rendering the webpage.
- Add an HTTP request module at the point where the trigger provides a URL.
- Set the request method, endpoint, and parameters to match the screenshot provider’s API documentation. Do not assume a provider uses the same parameter names or response format as another service.
- Configure authentication with the appropriate Make HTTP option: no authentication, API key, Basic Auth, or OAuth 2.0. Make advises placing credentials in its dedicated Credentials field.
- When the endpoint returns a file, use the HTTP download capability where appropriate, then map the resulting file to your storage, email, or messaging destination.
- Run a test with a URL you control and inspect the response before scheduling repeated calls.
For ScreenshotNeo, the request can be a GET to https://api.screenshotneo.com/v1/shot with the access_key and URL parameters; its API documentation covers the available capture options. Do not treat a successful HTTP response alone as proof that the intended page content rendered correctly—check a sample output.
Rank #4
Does Make’s URL screenshot action capture the whole page?
The documented description for HTML/CSS to Image is “Create a Screenshot of a URL” and “Take a screenshot of any website”; it does not establish a full-page option. If capturing content beyond the visible viewport is a requirement, verify the action’s current settings in Make or choose a route whose documentation explicitly supports the needed capture behavior. ScreenshotNeo, for example, lists full-page capture with lazy images loaded among its options.
Troubleshoot common screenshot workflow problems
- The destination receives no image. Check the scenario execution bundle to see whether the screenshot action returned an image and whether the destination module’s file or attachment input is mapped to that output. A URL string by itself is not the captured image.
- The wrong page is captured. Inspect the trigger bundle and confirm the screenshot module maps the intended URL field, especially when a trigger processes multiple records.
- The screenshot is incomplete or does not show expected content. The page may depend on JavaScript, delayed loading, a login, or interaction. A basic URL capture may not reproduce those browser steps; move to Custom JS browser automation or an interactive browser integration when the page requires them.
- An element capture fails or captures the wrong part. Confirm the selector identifies the desired element on the page and use GetScreenshot’s element action, which requires a selector. A selector for an element that is absent or different on that page cannot identify the intended target.
- The HTTP request is rejected. Check the endpoint, method, required parameters, and authentication against the provider’s current API documentation. In Make, verify that the credential is configured in the appropriate authentication field and that the request is passing the URL value from the trigger.
- The request works in a test but fails on a schedule. Compare the scheduled run’s input bundle and execution details with the successful test. Confirm that the trigger still supplies a valid URL and that any external account connection remains configured; test again before relying on recurring delivery.
- A capture step is slow or appears to hang. A remote page or screenshot service can take time to load or render. Inspect the failed execution and service response before adding retries; retries can repeat work and should be used only when appropriate for the endpoint and scenario.
Plan for reliable recurring captures
First validate one representative page for each kind of input you expect: a simple page, a page with delayed content, or a page requiring interaction. Keep the original URL next to the output so a later mismatch can be traced to its input. For recurring scenarios, check execution history and destination results rather than assuming a scheduled run produced a useful image.
Make’s documentation for the listed integrations does not establish a common screenshot quota, rendering success rate, or performance guarantee. Those details depend on the app, service, and applicable account terms. Avoid setting a capture schedule or retry policy from assumptions about limits; consult the relevant provider’s current documentation and monitor actual scenario executions.
Frequently Asked Questions
Can I use a spreadsheet as the source of screenshot URLs?
Yes. A spreadsheet row can serve as the scenario trigger or input source; map the row’s URL into the screenshot action and route the returned image to the destination you choose.
Can I use an authenticated or interactive browser session?
Use a browser-automation route when the capture depends on signing in, clicking, typing, or navigating. The basic URL screenshot action does not establish those session capabilities; Custom JS documents browser automation, while Anchor Browser Agent provides Chromium interaction modules, with limited public documentation.
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.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →
