How to capture screenshots of multiple URLs from Airtable with Make

To capture screenshots for multiple Airtable URLs with Make, create one Airtable record per webpage, watch a view of records ready for capture, send each record’s URL to a screenshot action, then update that same record with the result and status. Make lists screenshot actions from GetScreenshot and HTML to Image API; a Make HTTP request can call another provider’s API when needed. The exact result fields depend on the provider, so confirm the output with a small sample before processing a queue.

This guide covers a documentation-based workflow; it does not claim that a scenario was run. Make and provider modules can change, so check their current documentation when configuring an account.

1. Prepare the Airtable table

Create a table with one record per target URL. A practical starting schema is:

Field	Suggested type	Purpose
URL	URL or single-line text	The public webpage to capture.
Status	Single select or text	Queue state such as Ready, Processing, Complete, or Error.
Screenshot result	URL, attachment, or text	Store the provider’s returned value in a type that accepts it.
Captured at	Date with time	Record when a successful capture finished.
Error	Long text	Store a concise provider or scenario error for retry decisions.
Created Time or Last Modified Time	Airtable computed field	Required by Make’s Airtable Watch Records trigger.

Use a view such as Ready for capture that includes eligible records and excludes completed records. This keeps the trigger focused and helps prevent accidental recaptures. If you want edited URLs to be captured again, define that as an explicit state transition, for example changing Status back to Ready.

2. Build the Make scenario

1. Add Airtable — Watch Records. Connect Airtable, choose the base and table, select the queue view, and choose the available Created Time or Last Modified Time field. Make documents this trigger as watching newly created or updated records in a view; it requires one of those time fields. See Make’s Airtable modules documentation.
2. Choose a screenshot action. Make lists GetScreenshot’s Take Screenshot action and Take Element Screenshot action, and HTML to Image API’s Capture Website Screenshot action. The GetScreenshot Make app documentation says an active GetScreenshot account and API key are required. Review the current GetScreenshot app documentation, GetScreenshot and Airtable integration page, and HTML to Image API and Airtable integration page for current setup details.
3. Map the URL. In the capture action, map the URL field from the Airtable trigger record. For element capture, configure the CSS selector required by that action; otherwise use a full webpage capture.
4. Inspect the module output. Run one record and inspect the actual output bundle. Determine whether the provider returns a URL, file data, an attachment-ready value, or another result. The available documentation does not establish one universal output schema, so do not assume every provider returns the same kind of image link.
5. Update the Airtable record. Add an Airtable update action and map the trigger’s record ID. On success, write the observed result into a compatible field, set Status to Complete, set Captured at, and clear Error. Configure an error route where practical to write Status as Error and store a short error message.
6. Run a small sample, then enable the queue. Try a few accessible public webpages first. Check that the output opens, the desired page area is captured, and the result remains accessible for as long as you need it. Then enable the scenario and monitor its first production records.

3. Select a capture provider or API route

For a Make-native setup, Make lists GetScreenshot and HTML to Image API screenshot actions. GetScreenshot also documents an element screenshot action that requires a selector. Compare providers against the needs of your pages and the current terms of each service; the sources here do not establish a winner on price, speed, or reliability.

Route	What the cited documentation establishes	Check before relying on it
GetScreenshot Make app	Take Screenshot and Take Element Screenshot actions are listed; its Make app page says an active account and API key are required.	Current account requirements, capture controls, output type, limits, and price.
HTML to Image API Make app	A Capture Website Screenshot action is listed for a URL.	Current authentication, rendering options, output schema, limits, and price.
Make HTTP — Make a request	Make describes HTTP as a way to call APIs, including when an integration is unavailable.	The chosen provider’s API endpoint, authentication, parameters, response format, and error handling.

When comparing a provider, check whether it can reach the target pages, capture a full page or viewport as needed, wait for client-rendered content, authenticate to restricted pages, and return a result that Airtable can store. Review current request limits and prices directly with the provider. Make’s application connection guidance explains connecting services; it does not define a screenshot provider’s API schema.

4. Handle duplicates, retries, and bad URLs

• Keep a clear queue state. Only records marked Ready should enter the queue view. Mark a record Processing before capture if your scenario design supports it, then Complete or Error afterwards.
• Make retries intentional. A transient timeout may be retryable; a malformed URL or access-denied page may need correction first. Preserve the error and avoid resetting every failed record automatically.
• Expect edits to retrigger a watch. Since Watch Records can watch created or updated records in a view, updates made by the scenario may themselves be relevant to the trigger. Use the view and status logic to keep completion updates from re-entering the capture path.
• Decide how to treat redirects and inaccessible pages. Confirm whether the provider follows redirects and how it reports authentication screens, bot checks, or failed navigation. Store an outcome that lets you distinguish a valid screenshot from an unexpected page.
• Keep target URLs distinct from Airtable attachment links. The input here is a webpage URL in a URL or text field. An Airtable attachment download URL is a different kind of link and has separate expiry behavior.

5. Scale the queue and retain results

Make’s scenario schedule, module behavior, provider limits, and page-render times determine practical throughput; Airtable API limits alone do not tell you how many captures a scenario can finish. For custom integrations that call Airtable’s Web API, Airtable documents up to 100 records per page, a limit of 5 requests per second per base, and 50 requests per second for personal access token traffic from a user or service account. After a 429 response, Airtable says to wait 30 seconds before subsequent requests succeed. Use backoff and avoid tightly looping writes. See Airtable’s Web API guide and API rate-limit guidance.

For screenshot retention, decide whether Airtable should hold a link, an attachment, or only a provider job/result reference. Test the stored value after the run. Airtable says attachment download links obtained through its API are temporary, approximately two hours; that guidance applies to Airtable-hosted attachments, not URLs stored in ordinary URL and text fields. Do not use a temporary attachment download URL as permanent public storage. See Airtable’s attachment URL guidance.

6. Troubleshooting

Symptom	Likely cause	Fix
No records arrive in Make	The view is empty, the record is outside the filter, or the trigger’s Created Time or Last Modified Time field is missing or misconfigured.	Check the selected base, table, view, time field, and a newly created or updated eligible record.
The same record is captured repeatedly	The scenario’s update changes a field that causes the record to remain eligible in the watched view.	Exclude Complete and Processing records from the queue view; make retry state changes explicit.
The capture action rejects the URL	The URL field is empty, malformed, or contains a value other than a webpage URL.	Require a valid absolute URL before the record enters the queue, and inspect the mapped value in the Make run.
The screenshot is blank or incomplete	The page may render content late, require authentication, block automated access, or fail during navigation; the selected capture mode may also omit content.	Check provider wait/render controls and access requirements, then run a sample and inspect the returned page and output.
Airtable rejects the screenshot result	The mapped provider output may be a file or object while the Airtable field expects a URL or text, or vice versa.	Inspect the output bundle and map a compatible value or use an appropriate attachment workflow.
The Airtable update gets a 429 response	Custom Web API traffic exceeded Airtable’s per-base request limit.	Wait 30 seconds after a 429, reduce request frequency, and add backoff for later retries. Recheck current limits.
A saved attachment link stops working	The stored value may be an Airtable API attachment download URL that expires.	Use durable storage appropriate to your retention needs or refresh the attachment URL when needed.
A Make provider module cannot connect	The service may require a separate account or API key, or its current connection flow may have changed.	Follow that provider’s current Make app documentation and verify credentials with the provider.

7. Cost and reliability considerations

Budget for both Make scenario operations and the selected screenshot provider according to their current pricing and usage rules. The cited Make integration pages establish available actions but do not provide enough evidence to compare provider prices or capture quality. Airtable’s documented API limits matter when custom API traffic is part of the flow; they do not set Make’s overall scenario throughput.

For reliability, keep a record-level status and error, test a small batch, avoid automatic infinite retries, and periodically review failed records. If an image is important for audit or long-term reference, confirm that the stored result is durable and that your process can recover it if a provider link expires.

Or skip the browser setup

Use ScreenshotNeo when you want a single API call per URL rather than configuring and maintaining a browser capture service. It is a website screenshot API and MCP server from ScreenshotNeo. In Make, use an HTTP request configured from the ScreenshotNeo API documentation; map the Airtable URL into the request’s url parameter and your key into access_key. Store the response according to the configured output and the Airtable field type.

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}`);

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. See the docs for request options and sign up free for 1,000 screenshots a month, with no card.

FAQ

Can I capture only part of each page?

Yes, if the selected capture action supports element capture. Make lists a GetScreenshot element action that requires a CSS selector; confirm its current configuration in the provider documentation.

Can I run this directly from an Airtable automation?

Airtable says its automations do not include a generic action for sending HTTP requests to any URL. For an Airtable automation, its documented route is a Run a script action using fetch(); for this guide’s workflow, Make orchestrates the modules. See Airtable’s integration options.

Will every provider return a permanent image URL?

No universal output type is established by the cited Make pages. Inspect the selected provider’s actual response and confirm its retention behavior before treating a returned link as permanent.