How to Screenshot a Website in Make (No Custom Module)

Short answer: drop the HTTP module into a Make scenario, point it at https://screenshotrender.com/api/v1/screenshot?apiKey=YOUR_API_KEY&url=https://news.ycombinator.com&fullPage=true, and you have a hosted PNG ready for the next module in under five seconds. No custom app to install, no headless Chrome to maintain, no custom function step.

By the end you'll have a working Make scenario that turns any URL into a hosted screenshot you can pipe into Airtable, Google Sheets, Slack, or wherever the rest of your automation goes, including JavaScript-heavy and Cloudflare-protected pages.

Why is there no native screenshot app in Make?

Make has thousands of apps in its marketplace but no dedicated screenshot module, so searching "screenshot" in the app library comes up empty.

That is not a gap you need to fill with a browser extension or a Webhook wired to a running Chromium instance. The HTTP module in Make does exactly what you need: it fires a GET request to any endpoint and returns the JSON response as a bundle for the next module. A screenshot API sits cleanly behind it.

The alternative developers reach for first is spinning up a real headless browser and triggering it via a Webhook. That means servers to maintain, Chromium binaries to keep current, and memory headroom to budget, all to add a single step to a no-code workflow. The HTTP module approach avoids all of it. ScreenshotRender runs the browser on its end and returns a hosted image URL your scenario can use immediately. If you use n8n instead of Make, the same pattern works in our n8n screenshot guide.

How do you screenshot a website in Make with one HTTP module?

Add the HTTP module to your scenario, choose the "Make a request" action, set the method to GET, and paste the full ScreenshotRender URL into the URL field:

https://screenshotrender.com/api/v1/screenshot?apiKey=YOUR_API_KEY&url=https://news.ycombinator.com&fullPage=true

Replace YOUR_API_KEY with your sr--prefixed key from the ScreenshotRender dashboard. The url parameter is the page you want to capture. fullPage=true screenshots the entire scrollable document instead of the default 1280 by 720 viewport. Leave the request body empty.

The one setting you must enable is Parse response. Make returns the raw JSON body as a string by default. With Parse response on, the fields become a proper data bundle that downstream modules can read directly. Set Response type to JSON. That is the entire module configuration.

Click Run once and the output will include a data.screenshot field containing a hosted image URL. Test the exact URL in the interactive playground first so you know the call works before you wire downstream modules onto it.

If the target URL has its own query parameters, percent-encode the inner URL so Make does not treat its & characters as separators in your own query string. The MDN percent-encoding reference covers the rules. In practice, wrapping the target URL in a Make encodeURL() formula handles it in one step.

How do you use the screenshot URL in the next Make module?

Reference the screenshot with {{N.data.screenshot}} where N is the position number of the HTTP module in your scenario. Make assigns each module a number automatically; hover over the module header to see it.

The response bundle also includes data.title, data.description, and data.favicon from the target page. Those come free with every screenshot call and are useful when you are building link preview cards rather than just storing raw images.

Three common downstream patterns:

• Airtable: add an Airtable Create or Update Record module, map an attachment column to {{N.data.screenshot}}. Airtable downloads and stores the file itself, no binary transfer step needed.
• Google Sheets: add a Google Sheets Add a Row module, drop {{N.data.screenshot}} into a URL column. The cell becomes a clickable link to the hosted image.
• Slack: add a Slack Send a Message module, include {{N.data.screenshot}} in the message text. Slack auto-unfurls the image inline.

How do you screenshot a JavaScript-heavy or Cloudflare-protected page from Make?

Add wait=2 to the request for single-page apps, and enable Stealth Mode on the Hobby plan or above for Cloudflare-protected pages.

For a React or Vue app that continues rendering after the initial HTML load, add the wait parameter in seconds:

https://screenshotrender.com/api/v1/screenshot?apiKey=YOUR_API_KEY&url=https://app.netlify.com&fullPage=true&wait=2

Two seconds is the API's built-in default wait time, chosen as a reasonable baseline for apps that swap content based on user state or feature flags after network idle. You can raise it for slower apps or pass a timeout value in seconds to cap the total request time if a slow page might stall your scenario.

Cloudflare is a different problem. Vanilla headless Chrome gets a 403 or a JavaScript challenge on most Cloudflare-protected pages because of bot fingerprinting signals that Cloudflare Turnstile is built to detect. ScreenshotRender bundles Stealth Mode on the Hobby plan and above (see the pricing page for the breakdown), so Cloudflare, DataDome, and similar challenges clear without any flags in the HTTP module.

Cookie banners, GDPR consent popups, ad overlays, and chat widgets are removed automatically on every plan including the free one. That is one fewer thing to work around inside your Make scenario.

When does this approach fail?

Three situations where the HTTP module plus hosted API path breaks down or needs a workaround:

• Internal URLs not reachable from the public internet. A hosted screenshot service cannot render http://localhost, http://10.0.0.5, or VPC internal dashboards. For internal screenshotting you need a headless browser inside the same network.
• High-frequency scenarios that hit rate limits. The free plan caps at 40 requests per minute and the Hobby plan at 60. If your scenario fans out across many URLs in a short window, add a Sleep module between iterations or upgrade to a plan with a higher per-minute cap.
• Pages behind authentication. ScreenshotRender's public API takes a URL, not a cookie jar or a logged-in session. If the target page requires login, generate a public share link on the source app first and screenshot that, or run a self-hosted browser inside the same session.

Everything else, including the large majority of cases where you want a PNG of a public marketing page, a blog post, a competitor's pricing page, or a dashboard embed, the HTTP module path is the right answer.

Common questions about screenshots in Make

Do I need a paid Make plan to use this?

No. The HTTP module is available on every Make plan including the free tier. ScreenshotRender also has a free plan with 100 screenshots per month and no credit card required, so the entire setup costs nothing while you test it.

How do I schedule a daily screenshot in Make?

Add a Schedule module as the first step in your scenario, set it to run daily at whatever time you need, then wire it into the HTTP module calling ScreenshotRender. A daily snapshot of a competitor's pricing page or your own landing page takes three modules and no code.

How do I save the screenshot to Google Drive from Make?

Add a second HTTP module after the ScreenshotRender call. Set the method to GET, set the URL to {{N.data.screenshot}} where N is the first HTTP module number, and turn Parse response off so Make treats the response as a binary file. Wire that module into a Google Drive Upload a File module to store it.

What is the cheapest way to add screenshots to a Make scenario?

Use Make's free tier and ScreenshotRender's free plan. 100 screenshots per month, cookie banner and ad removal enabled by default, full page capture supported, no credit card required on either side. If you need Stealth Mode for Cloudflare or a higher per-minute cap, ScreenshotRender's Hobby plan is $10 per month billed annually with 2,000 screenshots included.

Can I screenshot multiple URLs at once in Make?

Yes. Use an iterator module to loop over a list of URLs, then wire each into the HTTP module calling ScreenshotRender. Each iteration triggers one API call. Watch the rate limit: the free plan caps at 40 requests per minute and the Hobby plan at 60, so add a Sleep module between iterations if you are processing large batches.

The honest verdict: if your Make scenario needs a screenshot and you do not already maintain a headless browser somewhere, the HTTP module calling a hosted API is the fastest and cleanest path. One module, one GET request, a hosted PNG for the next step in your workflow.