How to Take Website Screenshots with Microlink in Make.com

To take a website screenshot with Microlink in Make.com, add Make’s HTTP Make a request module and send a GET request to https://api.microlink.io with the target page in url and screenshot=true. For a screenshot-only workflow, also set meta=false. Microlink returns JSON; the hosted image URL is at data.screenshot.url. If a later module needs the image file itself, pass that URL to Make’s HTTP Download a file module.

1. Configure the Microlink request in Make

Open a Make scenario and add the HTTP app’s Make a request module. Make’s HTTP app can call API services that do not have a dedicated Make integration. [Make HTTP app documentation]
Set Method to GET and the URL to https://api.microlink.io.
Add the query parameters shown below. Use the URL of the page you want to capture as the value of url.
Run the scenario once. Inspect the JSON output and map data → screenshot → url into the next module.

Parameter	Value	Purpose
`url`	The page to capture, such as `https://example.com`	Target webpage.
`screenshot`	`true`	Enables screenshot capture.
`meta`	`false`	Skips page metadata extraction when the scenario only needs a screenshot.

Microlink’s screenshot guide identifies url and screenshot as the required parameters. It documents meta=false as an option that skips metadata extraction, which is usually the biggest speedup for screenshot-only requests. [Microlink screenshot guide]

Use separate query fields in Make

When the module presents a query-string section, create one entry for each parameter instead of assembling a raw URL by hand:

url        https://example.com
screenshot true
meta       false

Make encodes query values when building the request. If you construct a raw query string yourself, URL-encode the target URL; its own ?, &, and other reserved characters must not be mistaken for parameters to Microlink.

Request URL shape

GET https://api.microlink.io?url=https%3A%2F%2Fexample.com&screenshot=true&meta=false

Use your actual page URL in place of https://example.com. The encoded string above is illustrative; let Make encode the parameter when possible.

2. Use the screenshot URL or download the image

The regular response is JSON. Its data.screenshot.url field is a hosted image URL, and the screenshot object includes image details such as type, size, width, and height. [Microlink screenshot guide]

Pass along a link: map data.screenshot.url into a later module that accepts an image URL.
Pass along a file: add the HTTP app’s Download a file module and map the screenshot URL into its URL field. The module retrieves a file from a specified URL. [Make HTTP app documentation]

Choose based on what the next step accepts. A URL is enough for a module that can fetch remote images; use the download step when the destination expects file data.

3. Choose capture options

Microlink documents screenshot settings for full-page captures and image output type. In a raw query string, nested parameters use dot notation; for example, screenshot.fullPage=true. Check Microlink’s parameter documentation for accepted values and current behavior. [Microlink screenshot guide]

Need	Parameter shape	What to consider
Capture the full page	`screenshot.fullPage=true`	Use when content below the initial viewport matters. Long pages can produce larger images.
Choose an image format	`screenshot.type=...`	Select a supported output type documented by Microlink and verify the returned screenshot metadata.
Screenshot without extracted page metadata	`meta=false`	Omit metadata work when the scenario does not consume it.

In Make, add these as individual query parameters with the documented dotted names when supported by the module. Avoid assuming a screenshot will match every user’s local browser: the result is what Microlink’s browser service renders for the submitted URL, and a site can restrict access or behave differently in an automated browser.

4. Reuse the request outside Make

These examples show the same API request shape for debugging or for a script that needs to make the capture directly. Keep the target URL encoded by the HTTP client.

cURL

curl -G 'https://api.microlink.io' \
  --data-urlencode 'url=https://example.com' \
  --data 'screenshot=true' \
  --data 'meta=false'

The response is JSON. Read data.screenshot.url from it to get the hosted image.

Python

import requests

response = requests.get(
    "https://api.microlink.io",
    params={
        "url": "https://example.com",
        "screenshot": "true",
        "meta": "false",
    },
    timeout=90,
)
response.raise_for_status()
data = response.json()
print(data["data"]["screenshot"]["url"])

Node.js

const params = new URLSearchParams({
  url: 'https://example.com',
  screenshot: 'true',
  meta: 'false',
});

const response = await fetch(`https://api.microlink.io?${params}`);
if (!response.ok) {
  throw new Error(`Microlink request failed: ${response.status} ${response.statusText}`);
}
const result = await response.json();
console.log(result.data.screenshot.url);

5. Troubleshoot common problems

Symptom	Likely cause	What to check
No screenshot field in the response	The request did not enable screenshot capture or the request failed.	Confirm `screenshot=true`, then inspect the complete API response for an error or missing data.
Make cannot parse the response as expected	The scenario is treating the response as a file or the response is not the expected JSON.	Use the JSON response from Make a request; map `data.screenshot.url` from its parsed output.
The next module receives a URL but needs a file	A hosted URL is a reference, not downloaded file data.	Add HTTP Download a file and provide the mapped screenshot URL.
The URL parameter appears split or malformed	A raw query string contains an unencoded target URL.	Use Make’s query parameter fields or URL-encode the complete target URL.
The capture is missing content or differs from a local browser	The target page may load content conditionally, restrict automated access, or render differently in the capture service.	Check that the URL is publicly reachable and compare the returned image with the page’s behavior. The documentation does not promise that every target will allow or match a capture.
Request takes longer than expected	Page rendering and optional metadata extraction add work.	For screenshot-only scenarios, set `meta=false`. Keep in mind this does not guarantee a particular response time.

6. Performance, reliability, and cost

Reduce unnecessary work: use meta=false when metadata is not used. Microlink describes this as skipping metadata extraction and says it is usually the biggest speedup for screenshot-only requests. [Microlink screenshot guide]
Keep the scenario’s data needs small: pass the screenshot URL when possible; download the file only for steps that require file content.
Plan for target variability: pages can restrict automated access or render differently in a hosted browser. Inspect the response and handle unsuccessful requests in the scenario rather than assuming every URL succeeds.
Check current limits: Microlink’s guide advertises use without an API key and 25 free requests per day for testing. Limits and plan terms can change, so check its current documentation and product page before relying on an allowance. [Microlink screenshot guide] [Microlink]

7. Or skip the browser setup

If your Make scenario needs a screenshot but you do not want to assemble and manage the capture request, ScreenshotNeo provides a website screenshot API and MCP server. Its one-call API returns an image or PDF, and the ScreenshotNeo docs describe its request options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

ScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets. Bot checks, blank pages, and failed loads are never billed. Its MCP server gives AI agents tools to take screenshots. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.

FAQ

Does Make have a dedicated Microlink module?

This workflow uses Make’s general-purpose HTTP app to call Microlink’s API.

Can I get a direct image response instead of JSON?

Microlink documents an embed=screenshot.url delivery mode for a direct image response in HTML, CSS, Markdown, or social tags. For the usual Make workflow, JSON makes it straightforward to map the screenshot URL and optionally download the file. [Microlink screenshot guide]

Which HTTP module version should I use?

Make’s documentation describes HTTP app Version 4 and notes that legacy users may select Version 3. The exact interface labels can vary by version. [Make HTTP app documentation]