How to Save Website Screenshots to OneDrive from a Make Scenario

To save website screenshots to OneDrive from a Make scenario, connect a trigger that supplies a page URL to a screenshot action, then pass the screenshot file or a downloadable screenshot URL to OneDrive’s Upload a File module. The key setup detail is checking what the screenshot action actually returns: map file data to an upload action, or use a usable URL with Upload a File by URL.

This guide uses Make’s GetScreenshot integration for the do-it-yourself capture step. Make lists whole-page and element screenshot actions; the GetScreenshot connection requires an active account and API key. See Make’s GetScreenshot integration and GetScreenshot app documentation.

1. Choose a trigger and define the input

A Make scenario is a workflow assembled from modules. Start it on a schedule, or use an event from another app to provide a page URL. For example, a spreadsheet row can supply the URL, but any trigger that exposes a URL field can work.

1. Create a scenario in Make and add the trigger app and event that fit your process.
2. Make sure the trigger produces a complete, reachable URL, including https://.
3. Decide how you will name the output file. A source record ID or date can help distinguish repeated captures.

Make describes scheduled and event-triggered capture patterns on its GetScreenshot integration page. Choose the trigger based on how often you need a screenshot and where its URL originates.

2. Add and connect the screenshot action

1. Add the GetScreenshot app to the scenario.
2. Choose Take Screenshot for a whole webpage. Choose Take Element Screenshot when you need a specific page element and have a selector for it.
3. Create the GetScreenshot connection with an active account and API key, as required by the app documentation.
4. Map the URL from your trigger into the screenshot action’s URL input. For an element capture, provide the selector expected by that module.

Run the scenario once with a real sample URL. Inspect the screenshot module’s output bundle before configuring the upload. The available documentation describes the actions, but does not guarantee that every account or module output exposes the result in the same form.

3. Map the screenshot into OneDrive

Choose the handoff based on the screenshot action’s actual output:

Screenshot output	OneDrive path	What to map
File data is present	Upload a File	Map the file data and filename into the OneDrive upload fields.
A usable downloadable URL is present	Upload a File by URL	Map the URL and choose the destination folder and filename.
A URL is present, but the upload-by-URL path cannot use it	HTTP Download a file, then OneDrive Upload a File	Download the URL to file data in Make, then map the resulting file into the upload action.

1. Add the relevant OneDrive upload module after the screenshot action, or after HTTP if you need to download the screenshot first.
2. Create a OneDrive connection, authenticate, and approve the requested access.
3. Select the destination folder. Set the filename using a fixed name or values from the trigger, such as a record identifier or date.
4. Map the screenshot’s file data or the downloaded file into the upload module. If using upload by URL, map the actual downloadable URL.
5. Run a sample and confirm the new file appears in the intended folder and opens as an image.

Make documents HTTP actions for making API requests and downloading files, and OneDrive actions for uploading files, including upload by URL. Check the module output and mappings in your own scenario. See Make’s HTTP and OneDrive integration and OneDrive app documentation.

4. Run a sample and then schedule the scenario

Before enabling a recurring schedule, run one complete scenario execution with a representative page URL. Check each handoff: trigger URL, screenshot result, any HTTP download, and OneDrive upload. Confirm the folder, image contents, and filename. If the capture module returns a URL instead of file data, verify that the URL can be fetched by the chosen OneDrive or HTTP path.

When the sample succeeds, configure the scenario’s schedule or leave it connected to the intended event trigger. For a URL list, check that each input record produces the intended separate file and that filenames will not unintentionally overwrite earlier captures.

5. Troubleshoot common failures

Symptom	Likely cause	Fix
Screenshot connection cannot be created	The GetScreenshot account is not active or the API key is missing or incorrect.	Confirm the account and API key, then recreate or update the Make connection. The GetScreenshot app documentation specifies these connection requirements.
The screenshot action has no URL or captures the wrong page	The trigger field was not mapped, or the supplied value is not the intended full URL.	Inspect the trigger bundle and map the correct URL field. Test with a known page URL.
OneDrive upload receives no file	The scenario mapped a URL where file data is needed, or mapped the wrong output field.	Inspect the screenshot action’s output bundle. Use upload by URL for a usable URL, or download the file with Make’s HTTP action and map its file result to Upload a File.
Upload by URL fails	The supplied address may not be a downloadable file URL or may not be accessible to OneDrive.	Try Make’s HTTP Download a file action and pass the downloaded file data to OneDrive’s file upload action.
OneDrive reports an upload failure	Make identifies file-size limits, exhausted storage quota, and a destination folder that no longer exists as possible causes.	Check the file size and OneDrive storage, then confirm the selected folder still exists and the connection can access it. See OneDrive app troubleshooting.
Element screenshot is empty or misses the target	The selector may not identify the intended element on the supplied page.	Check the selector against the page and confirm that the element exists for the URL being processed. Use whole-page capture if the target is not stable.
Repeated runs replace or confuse files	The scenario uses a fixed filename for changing captures.	Include a source identifier or date in the mapped filename, and check the destination folder’s behavior for duplicate names.

6. Reliability, performance, and cost considerations

• Validate handoffs: a successful screenshot action does not by itself confirm that OneDrive received the image. Inspect the upload result and periodically confirm files are in the expected folder.
• Plan for changing pages: pages may change or become unavailable, and a selector that works today may not identify the same element later. Prefer whole-page capture when an element selector is not dependable.
• Keep filenames traceable: include the source record or another useful identifier so a saved screenshot can be connected to its input.
• Watch storage and file-size limits: OneDrive upload failures can result from file-size limits or exhausted storage. The scenario’s volume and retention policy affect how quickly stored captures accumulate.
• Review service terms and account costs: the cited integration documentation establishes the available modules and setup, but does not establish current Make, GetScreenshot, or OneDrive prices or quotas. Check each service’s current plan details for your expected run frequency and storage use.

7. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from ScreenshotNeo. You can call it from Make with an HTTP request and then route its image response through the scenario to OneDrive. Consult the ScreenshotNeo API documentation for request details.

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

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Replace the example URL with the URL supplied by your Make trigger and keep your API key private. In Make, put the ScreenshotNeo request before the OneDrive upload stage and map the resulting image data into the upload. Confirm the HTTP response and mapping in a sample run.

• Cookie banners are accepted and removed before the shot, along with known newsletter popups and chat widgets.
• Bot checks, blank pages, failed loads, timeouts, and cache hits are never billed; response headers identify the page verdict and billing status.
• An MCP server lets AI agents use screenshot tools.
• 1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000.

Sign up free for 1,000 screenshots a month with no card.

Frequently asked questions

Can I capture just one part of a webpage?

Yes. Make lists a Take Element Screenshot action for GetScreenshot. Use it when you have a selector for the element you want to capture.

Do I need to make the screenshot public to save it in OneDrive?

The documented workflow supports uploading file data or using a URL that the upload module can access. The cited documentation does not say that every screenshot must be made public; inspect the output and choose the appropriate handoff.

Can a spreadsheet supply the page URLs?

Yes, if the trigger module provides a URL field to map into the screenshot action. A Make community discussion describes a related spreadsheet-to-OneDrive workflow, but that post is one user’s use case rather than product documentation.