Guide

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.

Asad AliJanuary 10, 20269 min read

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

  1. Add the HTTP → Make a request module to a scenario.
  2. 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
  3. 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) and height (240–3840), or a device preset (desktop, laptop, tablet, mobile). There is no viewport object.
  • format is png, jpeg or webp on every plan. pdf and html need Basic.
  • mockup is a string template ID such as "browser-dark" (Growth plan), not an object.
  • Valid aiRemoval types are cookie-banner, newsletter, chat-widget, social-overlay and ad (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.

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 url and a name. 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)
  1. Add Webhooks → Custom webhook as the trigger and copy its URL.
  2. In the HTTP module, map the incoming url into the body and add "storage": { "enabled": true } (Basic plan). Set Parse response to Yes.
  3. Add Webhooks → Webhook response with status 200 and 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) and 500 (capture failed) responses. The Retry handler needs Store incomplete executions turned on in the scenario settings.
  • Resume or Commit with a notification for 400 and 403, 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 cookies or headers to 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/jobs queues 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:

make.com
no-code
automation
integrations

About the Author

Asad Ali

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.

Related Articles