Make.com Screenshot Integration: Automate Visual Capture Without Code
Build Make scenarios that capture web pages with the Screenshotly API and store the images, on a schedule or on demand.
Make (formerly Integromat) connects apps with visual scenarios. It has no Screenshotly app, but its HTTP app can call the API, receive the image and pass it to Google Drive, Dropbox, S3 or any module that accepts a file.
This guide covers the setup once, then three scenarios that build on it: a scheduled capture of a URL list, a weekly competitor snapshot and an on-demand capture triggered by a webhook. For a five-minute version, see the Make integration quickstart.
About field names: Make's current HTTP app (version 4) uses the labels below. Older scenarios built with the legacy HTTP modules show slightly different names (for example "Body type: Raw" instead of "Body content type"). The request itself is the same.
What you need
- A Make account. Each module run uses Make operations, which are billed as credits on your Make plan.
- A Screenshotly API key. The free plan includes 100 captures in total at up to 5 requests per minute, with PNG, JPEG and WebP output.
Step 1: Store the key in a keychain
- Add the HTTP → Make a request module to a scenario.
- Set Authentication type to API key and create a new keychain:
- Key: your Screenshotly API key
- API key placement: in the header
- API key parameter name:
x-api-key
- Optionally turn on Restrict requests to service URLs and enter
https://screenshotly.app, so the keychain can't be sent anywhere else.
A keychain keeps the key out of the module's visible headers, so it isn't exposed when you share a scenario or a screenshot of it.
Step 2: Configure the request
| Field | Value |
|---|---|
| URL | https://screenshotly.app/api/screenshot |
| Method | POST |
| Body content type | application/JSON |
| Body | the JSON below |
| Parse response | No (the response is the image) |
| Timeout | 60 seconds (a capture can take up to about 30) |
| Return error if HTTP request fails | Yes |
Request body:
{
"url": "https://example.com",
"width": 1280,
"height": 800,
"fullPage": true,
"format": "png"
}
Replace https://example.com with a mapped value from an earlier module, keeping it inside the quotation marks.
The API's schema is strict. It rejects unknown fields with 400 Invalid request data, which is the usual problem with older examples:
- Viewport size is top-level
width(320–3840) andheight(240–3840), or adevicepreset (desktop,laptop,tablet,mobile). There is noviewportobject. formatispng,jpegorwebpon every plan.pdfandhtmlneed Basic.mockupis a string template ID such as"browser-dark"(Growth plan), not an object.- Valid
aiRemovaltypes arecookie-banner,newsletter,chat-widget,social-overlayandad(Growth plan).
Step 3: Save the image
Run the module once with Run once so Make can show its output. The output includes the status code, the response headers and the response body. Because Parse response is off, the body is the raw image.
Then add your storage module, for example Google Drive → Upload a file or Dropbox → Upload a file. Make's file modules take two inputs:
- File name: something unique, such as
homepage-{{formatDate(now; "YYYY-MM-DD")}}.png. - Data: the response body from the HTTP module.
Alternative: get a download link (Basic plan and above)
If you'd rather work with a link, add "storage": { "enabled": true } to the body and set Parse response to Yes. The API then returns:
{ "success": true, "url": "https://screenshotly.app/api/assets/…?expires=…&signature=…", "format": "png", "size": 48213, "duration": 2140 }
Pass url to HTTP → Download a file, then map that module's file into your upload module, which is the pattern Make documents for moving files between apps. The signed link works for 24 hours, and the file is kept for your account's retention period (7 days by default). It isn't a permanent public URL.
Scenario 1: Capture a list of URLs every morning
Google Sheets: Search Rows (one bundle per URL)
↓
HTTP: Make a request (Screenshotly)
↓
Tools: Sleep (13 seconds)
↓
Google Drive: Upload a file
- Schedule: in the scenario's schedule settings, choose Daily and the time you want.
- Rows: each row has a
urland aname. Map them into the body ("url": "{{1.url}}") and the file name ({{1.name}}-{{formatDate(now; "YYYY-MM-DD")}}.png). Module numbers depend on your scenario. - Sleep: the free plan allows 5 requests per minute, so 13 seconds between captures stays under it. Basic allows 40, Growth 80 and Scale 200 per minute, so paid plans can sleep less or not at all. The Sleep module can wait up to 300 seconds.
- Quota: each URL uses one capture per run. Ten URLs a day uses about 300 captures a month, which needs a paid plan (Basic includes 2,500 a month). The free plan's 100 captures are a one-time allowance.
If your URLs are in a JSON array rather than a sheet, use Flow control → Iterator to turn the array into one bundle per URL.
Scenario 2: Weekly competitor snapshot
Scenario schedule: Weekly
↓
HTTP: Make a request (Screenshotly)
↓
Dropbox: Upload a file
↓
Slack: send a message ("New snapshot saved")
Body:
{
"url": "https://competitor.example/pricing",
"width": 1440,
"height": 900,
"fullPage": true,
"blockAds": true,
"waitForNetworkIdle": true
}
blockAds works on every plan. It blocks known ad requests and hides common ad and cookie-banner elements. To hide chat widgets and popups as well, add "aiRemoval": { "enabled": true, "types": ["cookie-banner", "chat-widget"] }, which needs Growth.
Make has no built-in image comparison, so this scenario stores the snapshots for a person to review. Comparing file sizes is not a reliable way to detect visual changes.
Scenario 3: Capture on demand from a webhook
Webhooks: Custom webhook
↓
HTTP: Make a request (Screenshotly, storage enabled)
↓
Webhooks: Webhook response (returns the link)
- Add Webhooks → Custom webhook as the trigger and copy its URL.
- In the HTTP module, map the incoming
urlinto the body and add"storage": { "enabled": true }(Basic plan). Set Parse response to Yes. - Add Webhooks → Webhook response with status
200and a body such as{"image": "{{2.url}}"}.
Call it from another system:
curl -X POST "https://hook.make.com/your-webhook-id" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com"}'
Anyone with the webhook URL can spend your captures, so keep it private or check a shared secret in a filter before the HTTP module.
Handling errors
With Return error if HTTP request fails set to Yes, Make stops on any 4xx or 5xx response. Right-click the HTTP module and add an error handler:
- Retry for
429(rate limit) and500(capture failed) responses. The Retry handler needs Store incomplete executions turned on in the scenario settings. - Resume or Commit with a notification for
400and403, because the request itself needs fixing.
The API's JSON error tells you which case you're in:
| Status | error |
What it means |
|---|---|---|
| 400 | Invalid request data, Invalid JSON, Unsafe URL | Unknown field, value out of range, bad JSON, or a private address |
| 401 | Authentication failed | Wrong or missing key; check the keychain's parameter name is x-api-key |
| 403 | Plan upgrade required | The option needs a higher plan; minimumPlan says which |
| 429 | Rate limit exceeded | Per-minute rate or quota reached; read message and the Retry-After header |
| 500 | Screenshot generation failed | The page blocked automation or didn't load within 30 seconds |
Failed captures don't count against your Screenshotly quota, but each module run still uses Make operations.
Tips
- Test with one URL first. Use Run once and check the HTTP module's output before adding storage.
- Name files uniquely. Include a date and a slug, or uploads may overwrite each other.
- Capture signed-in pages on Basic and above by adding
cookiesorheadersto the body. The API can't log in for you, so the session must come from your own system. - Use async jobs for big batches. On Basic and above,
POST /api/jobsqueues a capture and can call a Make custom webhook when it finishes. See async jobs.
Ready to automate your screenshots?
Create a free API key →. It includes 100 captures to test your scenario.
See also:
About the Author

Asad Ali
CTO at ZTABS and the developer behind Screenshotly. Writes about screenshot automation, API design, and building reliable SaaS backends with Next.js, Node.js, and TypeScript.
Credentials: CTO at ZTABS, full-stack developer, builder and maintainer of Screenshotly and its official JavaScript and Python clients
Frequently Asked Questions
Is there a Screenshotly app in Make?
No. You call the API with Make's built-in HTTP app and its Make a request module. The API key is stored in a Make keychain, so it doesn't appear in the module's headers.
How do I handle the binary image response in Make?
Leave Parse response off. The response body is the image, so map it, with a file name, into the Data field of an upload module such as Google Drive or Dropbox. On Screenshotly Basic and above you can instead request a signed download link and fetch it with HTTP > Download a file.
What happens when a capture fails in the middle of a scenario?
With 'Return error if HTTP request fails' set to Yes, a 4xx or 5xx response stops that bundle and Make runs your error handler. Use a retry for 429 and 500 responses, and a notification for 400 and 403, because those won't succeed on retry.
Ready to capture your first screenshot?
Get started with 100 free screenshots. No credit card required.