How to Use Apify Screenshot Results in Make.com
Send Apify screenshots through Make by fetching them from the run’s key-value store, then map the returned file or reference into your next app.
To use an Apify screenshot in Make.com, first find where the Actor stored it. Get Dataset Items retrieves structured rows from the run’s default dataset; it does not retrieve an image saved as a record in the run’s default key-value store. For that screenshot, fetch the key-value-store record using its store ID and record key, or use Apify’s run-scoped default-store endpoint. Then map the response into a downstream module that accepts the returned data format.
This distinction is the key to the workflow: a run can produce dataset items and separate key-value records. The Actor’s output schema and run details reveal which storage location and record key to use. Apify’s [Make integration guide](https://docs.apify.com/integrations/make) describes running Actors and retrieving dataset results; its [key-value-store record API](https://docs.apify.com/api/v2/default-key-value-store) documents retrieving records from a run’s default store.
How do I get Apify screenshots into Make?
Choose a run pattern, then retrieve the screenshot from the store where the Actor put it:
- Short-running Actor launched by this scenario: use Apify’s Run an Actor module synchronously, then use its run output to retrieve the screenshot record.
- Long-running Actor or a run started elsewhere: use Watch Actor Runs (or Watch Task Runs) as the trigger, then retrieve the record after the run finishes.
- Need structured results too? Add Get Dataset Items and map the run’s default dataset ID. This is separate from retrieving the screenshot.
Apify’s integration guide notes that synchronous execution waits for completion, while the hard timeout depends on the Make plan. If the Actor may exceed that timeout, use the watcher approach so the scenario continues when the run has finished. See [Apify’s Make integration documentation](https://docs.apify.com/integrations/make).
Before building the scenario
- Confirm the Actor actually saves a screenshot, and inspect its output schema or a completed run.
- Find the screenshot record key in the Actor’s output schema, run details, or the default key-value store’s keys.
- Determine whether the next Make module wants binary file data, an image URL, or another file representation. There is no single conversion that applies to every Actor and destination app.
- Connect Apify to Make using its Apify connection. Apify’s Make guide describes OAuth or an API token for the connection and recommends OAuth during setup.
Build a synchronous scenario for a short run
- In Make, create a scenario and add Apify’s Run an Actor module. Select the Actor and provide its expected JSON input. If the Actor is configured as a task, use the corresponding task action.
- Set the run to wait synchronously for completion. This is appropriate when the Actor reliably finishes within the timeout for your Make plan.
- Run the scenario once. Make can then expose the module’s output fields for mapping. Identify the run ID and default dataset and key-value-store IDs, if available.
- If you need structured rows, add Get Dataset Items and map the run’s default dataset ID into the Dataset ID field.
- For the screenshot, add Apify’s Make an API Call module, or use Make’s HTTP module. Send an authorized GET to the record endpoint using the key-value-store ID and screenshot record key.
- Map the returned content into the next app’s file or image input. Inspect the receiving module’s field type and test with one actual completed run.
The general key-value record route is:
GET https://api.apify.com/v2/key-value-stores/{STORE_ID}/records/{RECORD_KEY}In Apify’s Make an API Call module, use the route relative to the Apify API base if that is what its current configuration requests, and enter the record key as a path segment. The module’s exact field labels can change; follow the current Make interface. The full endpoint and run-scoped alternatives are in the [Apify API reference](https://docs.apify.com/api/v2/default-key-value-store).
Use Make’s Get Dataset Items for rows
The dataset module is useful when the Actor returns metadata such as page URLs, titles, or references to screenshots. Map the default dataset ID from the run output. If the dataset has no screenshot bytes, that can be expected: the image may exist as a separate key-value record.
Use a watcher for a long-running Actor or an external run
- Add Apify’s Watch Actor Runs trigger and select the Actor. For a task workflow, use Watch Task Runs if available in the current Apify app.
- Configure the trigger to react to finished runs. The run might have been started in another scenario, from Apify Console, or elsewhere.
- Use the run ID and storage IDs provided by the trigger output. Add Get Dataset Items for structured output, if needed.
- Separately fetch the screenshot record from the default key-value store using its record key.
- Map the screenshot response into the downstream module, checking whether it expects a URL, binary content, or a file object.
This pattern separates starting work from processing its result. It is useful when a run might be longer than a synchronous scenario can wait. The Apify guide describes the Make timeout as plan-dependent; do not rely on a universal timeout value.
Where does Apify store screenshots?
Apify Actors can write structured items to a dataset and files or other records to a key-value store. Those are separate stores with separate retrieval steps. Apify’s output-schema example distinguishes crawlResults, which points to the default dataset, from screenshots, which points to keys in the default key-value store. Your Actor may use different names and keys, so inspect its own output schema and a completed run.
When you know the store ID and record key, retrieve the record at:
GET https://api.apify.com/v2/key-value-stores/{STORE_ID}/records/{RECORD_KEY}If the scenario has a run ID but not the store ID, Apify also documents a convenience route scoped to that run’s default store:
GET https://api.apify.com/v2/actor-runs/{RUN_ID}/key-value-store/records/{RECORD_KEY}Use the API reference to confirm the route and accepted identifier form for the Apify module or HTTP module you chose. The response’s content type follows the MIME type stored with the record, so a record can return image data as well as text or JSON. See [Apify’s default key-value-store API reference](https://docs.apify.com/api/v2/default-key-value-store).
Find the screenshot key
- Open the Actor’s documentation and inspect its output schema for screenshot or file outputs.
- Open a completed run and inspect its default key-value store and list of keys.
- Use the exact record key shown for the image when building the request. Do not assume every Actor uses a key named
SCREENSHOTor any other common name. - Check whether the Actor writes a single screenshot, multiple screenshots, or a reference in the dataset that must be followed.
Call Apify’s record API directly
Make’s Apify API Call module is often the simplest way to keep the request inside a scenario. For diagnosis or a custom client, the equivalent HTTP request can be made with cURL, Python, or Node.js. Replace the placeholders with a real store ID (or use the run-scoped route), record key, and private API token.
cURL
curl --fail --show-error --location \
--header "Authorization: Bearer $APIFY_TOKEN" \
"https://api.apify.com/v2/key-value-stores/$STORE_ID/records/$RECORD_KEY" \
--output screenshot.pngUse a file extension that matches the stored image format. The request writes the response body to a file; inspect the record’s MIME type or Actor documentation rather than assuming every screenshot is PNG.
Python
import os
import requests
store_id = "YOUR_STORE_ID"
record_key = "YOUR_SCREENSHOT_KEY"
token = os.environ["APIFY_TOKEN"]
url = f"https://api.apify.com/v2/key-value-stores/{store_id}/records/{record_key}"
response = requests.get(
url,
headers={"Authorization": f"Bearer {token}"},
timeout=90,
)
response.raise_for_status()
with open("screenshot.png", "wb") as image_file:
image_file.write(response.content)
Node.js
const storeId = 'YOUR_STORE_ID';
const recordKey = 'YOUR_SCREENSHOT_KEY';
const token = process.env.APIFY_TOKEN;
const url = `https://api.apify.com/v2/key-value-stores/${storeId}/records/${encodeURIComponent(recordKey)}`;
const response = await fetch(url, {
headers: { Authorization: `Bearer ${token}` },
});
if (!response.ok) {
throw new Error(`Apify returned ${response.status}: ${await response.text()}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('screenshot.png', image));
For a run-scoped request, replace the URL path with /v2/actor-runs/RUN_ID/key-value-store/records/RECORD_KEY. Apify recommends sending API authentication in the Authorization: Bearer header rather than putting the token in the URL, where it could appear in histories or server logs. Keep credentials in Make’s connection or a secret store; do not paste them into a public scenario field. See the [Apify API authentication guidance](https://docs.apify.com/api/v2).
Pass the screenshot to another Make app
After the record retrieval step, map its output to the destination’s documented input type:
| Destination expects | What to map or do | Check |
|---|---|---|
| Binary image/file data | Map the API response body if the module exposes it as binary content. If not, use the receiving app’s file-upload operation and provide the response as a file. | Confirm the filename and MIME type match the stored image. |
| Image URL | Pass a URL only if the Actor or storage workflow provides an accessible URL. An authenticated API response is not automatically a public image URL. | Confirm the destination can access the URL and that it remains valid for the required period. |
| Dataset metadata | Map the relevant dataset fields using Get Dataset Items. | Metadata may reference a screenshot key but does not necessarily contain image bytes. |
Make’s receiving module determines whether you need a conversion or upload step. Apify’s record API establishes how to retrieve the stored record; it does not define a universal mapping for every downstream Make app.
Why does Get Dataset Items not show my screenshot?
Because the screenshot may be stored in the run’s key-value store, while Get Dataset Items reads the default dataset. Retrieve both stores when the workflow needs both structured information and image content. A dataset item can contain a screenshot reference or key, but that is distinct from the binary record itself.
Common errors and fixes
| Symptom | Likely cause | Fix |
|---|---|---|
| Dataset is empty or has no image field | The Actor stores screenshots as key-value records, or writes no dataset items. | Inspect the Actor schema and run’s default key-value store. Fetch the screenshot record by key. |
| No output fields are available to map | Make has not seen a sample output from the preceding module. | Run the scenario once, inspect the generated module output, then map the run and storage IDs. |
| Scenario ends before the Actor completes | The synchronous run exceeded the timeout for the current Make plan. | Switch to Watch Actor Runs or Watch Task Runs, then fetch the outputs after completion. |
| Record request returns unauthorized | The token is missing, invalid, lacks access, or the store is private to another account. | Check the Apify connection and permissions. For a direct request, use the bearer Authorization header and the correct account. |
| Record request returns not found | The store ID, run ID, or record key is wrong, or the run did not write that record. | Inspect the completed run’s key list and copy the exact identifier and key. Confirm the Actor saved the screenshot in the expected run. |
| Downstream module rejects the response | It expects a URL or file object, but received raw response data, or the MIME type/filename is wrong. | Check the module’s input contract. Add its required upload or conversion step and set the matching filename and content type. |
| Image appears corrupted or has the wrong extension | The file was saved with an extension that does not match its actual format, or the response was mapped as text. | Inspect the response MIME type and map/save the body as binary data. |
Performance, reliability, and cost considerations
- Runtime: synchronous execution couples the scenario’s wait to Actor runtime. For longer or variable runs, use a completion watcher and fetch outputs afterward.
- Payload size: screenshots can be larger than metadata rows. Avoid passing image bytes through steps that only need a URL or key, and avoid downloading the same record more than needed.
- Retries: if a record fetch fails transiently, retry the retrieval step after checking the run has completed. Ensure downstream actions do not create duplicate uploads or messages when Make retries a scenario.
- Storage and billing: this workflow uses Apify and Make features, whose usage and plan limits depend on the accounts and Actor involved. Check each service’s current plan and billing details; the sources here do not establish a universal per-screenshot cost.
- Credentials: treat API tokens as secrets. Use Make’s authenticated connection or a protected secret, and keep tokens out of query strings and exported scenario examples.
Or skip the browser setup
If your goal is simply to capture a webpage rather than run an Apify Actor, ScreenshotNeo provides a one-call screenshot API. See the [ScreenshotNeo API documentation](https://screenshotneo.com/docs/).
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpimport 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}`);ScreenshotNeo removes cookie and consent banners, newsletter popups, and chat widgets before capture. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots, and 1,000 screenshots each month are free with no card; paid plans start at $5 for 3,000. ScreenshotNeo is a website screenshot API and MCP server made by [Yorker Media](https://screenshotneo.com), with PNG, JPEG, WebP, and PDF output. [Create a free account](https://screenshotneo.com/account/sign-up/) to get 1,000 screenshots a month with no card.
Frequently asked questions
Can a Make scenario process a screenshot created before the scenario runs?
Yes. Use a watcher for the relevant Actor or task run, then retrieve the screenshot record using the run output. The Actor must retain the record and expose or document its key.
Can one run return several screenshots?
It can, depending on the Actor. Inspect the key-value store’s key list and build the scenario around the actual output rather than assuming one fixed screenshot key.
Does the dataset ID identify the screenshot file?
No. It identifies the dataset used for structured items. A screenshot saved to the default key-value store requires a separate record lookup.
Should I use a public URL instead of downloading the record?
Only when the Actor or storage workflow provides a URL that the destination app can access. Otherwise, retrieve the record and use the file or binary input supported by the destination.
