How to Capture Screenshots of Several URLs from Google Sheets with n8n

To capture screenshots for URLs in Google Sheets with n8n, read the sheet rows, filter out empty or already completed URLs, call a screenshot service once for each remaining row, receive each response as a binary file, and upload it to Google Drive. Then update the source row with the file link, capture time, and status. The workflow below uses n8n’s built-in Google Sheets, HTTP Request, and Google Drive nodes, so it does not require a browser installation or a community node.

The screenshot endpoint and its authentication, query parameters, and supported image options depend on the provider. This guide uses ScreenshotNeo for the API request; its [API documentation](https://screenshotneo.com/docs/) describes the available parameters. Keep the API key in n8n credentials.

1. Prepare the sheet and storage

Create a header row in Google Sheets. n8n treats the first row as column headings when reading rows. Use a stable identifier such as id if available; otherwise preserve the row number or other row key provided by the Google Sheets node so the workflow can update the exact source record later. The built-in node supports reading all rows by default and adding filters. See the [Google Sheets node documentation](https://github.com/n8n-io/n8n-docs/blob/main/docs/integrations/builtin/app-nodes/n8n-nodes-base.googlesheets/sheet-operations.md).

url	title	status	screenshot_url	captured_at	error
https://example.com	Example home	pending
https://example.org	Example org

Create a Drive folder for the image files. Decide who needs access: a Drive link only works for people with permission to open that file. Set up Google credentials in n8n for both Sheets and Drive, and create an n8n credential for the screenshot API key rather than putting the secret directly into an expression or URL.

2. Build the n8n workflow

Read rows: Add a Google Sheets node, choose the spreadsheet and tab, and use Get Row(s). Configure filters if you want to retrieve only pending rows.
Validate and skip: Add a filter or IF node to allow rows with a non-empty URL and a blank or pending status. Keep the row key and original URL in the item for later writeback.
Capture one URL per item: Add an HTTP Request node. Configure the ScreenshotNeo request as shown below and set its response format to File. Choose a named binary output field, for example data.
Upload the binary: Add a Google Drive upload node. Select the same binary field (data) as the input file. Use a filename based on a sanitized title or hostname plus the row identifier, for example example-com-row-12.webp. Save the returned file ID or link for the next step.
Update the source row: Use Google Sheets row update functionality to write success, the Drive link, and capture time to the matching row. Map the row key from the original item, not a row position inferred after filtering.
Handle errors per item: Configure the request and upload steps to continue processing other rows when one item fails, using the node’s error handling settings available in your n8n version. Route failed items to an update step that records an error status and a concise error message for that row.

The HTTP Request node supports query parameters, credentials such as Generic Credential Type with Query Auth, batching, and a File response format that places the response into a named binary field. See the [HTTP Request node documentation](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest) for the current labels and settings. Select the option that stores the response as a file and enter the output field name.

ScreenshotNeo HTTP Request settings

Setting	Value
Method	GET
URL	`https://api.screenshotneo.com/v1/shot`
Authentication	n8n credential using Query Auth; parameter name `access_key`, value your API key
Query parameter	`url` mapped from the current row’s `url` field
Response format	File
Put output in field	`data`

In the node’s query parameter editor, map the URL value from the current input item using the expression picker, rather than typing a sample URL as a fixed value. Do not include the API key in a sheet cell or a manually constructed public link. If you use another provider, replace the endpoint, auth credential, and parameters with that provider’s documented settings; request syntax is not universal.

Binary field and filename details

The HTTP Request output has JSON data and a binary property. The Drive upload node must use the exact binary property name configured in the HTTP Request node. A mismatch often appears as a missing binary data error. For filenames, remove path separators and other unsafe characters from sheet titles, and include a stable row identifier to avoid collisions when titles repeat. Keep the original URL separately in Sheets for traceability.

3. Configure batching and writeback

For a small sheet, first run a few rows and inspect both the binary output and the uploaded files. For larger sheets, use the HTTP Request node’s batching controls to limit how many requests are sent in a short interval. A modest delay can reduce pressure on the screenshot service and target sites. There is no universal safe throughput number: it depends on the provider, n8n host, target pages, image sizes, and concurrency.

Make the workflow safe to rerun. Filtering for blank or pending status avoids recapturing completed rows. If a previous run uploaded the file but failed before updating Sheets, you may otherwise create a duplicate. You can reduce duplicates by writing a processing state before capture, retaining a stable filename, and deciding how the upload step should behave when that name already exists.

For each successful item, write the returned Drive link and capture timestamp to its source row. For errors, record the failed stage and a useful message, while allowing subsequent rows to continue. Avoid recording credentials or sensitive page content in error fields or execution logs.

4. Complete runnable API examples

These examples show the same ScreenshotNeo request outside n8n, useful for checking a single URL or understanding the HTTP call. Replace YOUR_API_KEY and the target URL. ScreenshotNeo returns the image response; save the response body as a file. In n8n, use the binary response setting described above. More request options are in the [ScreenshotNeo docs](https://screenshotneo.com/docs/).

cURL

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

Python

import requests

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

Node.js

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com',
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

Or skip the browser setup

Use [ScreenshotNeo](https://screenshotneo.com) as the screenshot step: it takes one GET request with a URL and returns an image or PDF. For n8n, make this request once per Google Sheets row and store the binary response in Drive. Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. An MCP server lets AI agents use the take_screenshot, get_page_info, and capture_pdf tools. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000.

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

See the [ScreenshotNeo API documentation](https://screenshotneo.com/docs/) for request options, then [sign up free](https://screenshotneo.com/account/sign-up/) to get 1,000 screenshots a month with no card.

5. Options and workflow choices

Core HTTP Request node or a community node

The core HTTP Request route works with screenshot providers that expose an API and keeps the workflow centered on n8n’s built-in nodes. It requires that you configure each provider’s authentication, parameters, binary response, and error handling. A community node or template may package those steps, but check its hosting requirements and maintenance before adopting it. The cited n8n template uses CustomJS PDF Toolkit and states that community nodes can only be installed on self-hosted n8n. Its example combines a Google Sheets trigger, capture step, and Drive upload; see the [template requirements and workflow](https://n8n.io/workflows/3332-capture-website-screenshots-via-google-sheets-to-google-drive-with-customjs/).

Read existing rows or trigger on new rows

Use Get Row(s) for a one-time or scheduled sweep of existing URLs. Use a Sheets trigger if the job should begin when new rows arrive, then keep the same validation, screenshot, upload, and writeback stages. In either setup, filter out blank URLs and completed records, and retain the source row identity.

Screenshot settings

Only send settings your provider documents and that the workflow needs. Common concerns include output format, full-page capture, viewport, and capture wait behavior, but the exact parameter names and supported choices vary. Smaller viewport captures and appropriately sized output images generally reduce transfer and storage needs; confirm provider behavior before relying on a particular option. ScreenshotNeo supports PNG, JPEG, WebP, PDF, full-page capture with lazy images loaded, CSS selector element capture, device presets and custom viewport, retina scale, wait conditions, and other options listed in its [documentation](https://screenshotneo.com/docs/).

6. Performance, reliability, and cost

Each URL normally means one screenshot request and one file upload, plus row reads and updates. The time and storage required depend on the destination pages, capture settings, image dimensions, provider response time, and n8n’s hosting setup. Use batching and a modest delay for large lists. Keep execution binary data in mind: image responses can consume memory or execution storage, especially when many items are processed together. The HTTP Request node documentation covers batching and binary response configuration; Site-Shot’s [n8n tutorial](https://www.site-shot.com/blog/n8n-website-screenshots/) also discusses binary handling as that provider’s guidance, not a universal resource guarantee.

Reliability comes from isolating failures per row, retaining a stable row key, and making retries deliberate. A transient timeout may be worth retrying; an invalid URL or access-denied page likely needs correction or an alternate access method. If the upload succeeds but writeback fails, use a predictable filename or another deduplication strategy before rerunning. Verify that Drive links have the intended permissions.

Cost has several parts: n8n hosting, screenshot service usage, and file storage. The supplied research does not establish a neutral benchmark across screenshot vendors, so throughput, relative cost, and reliability should be measured against your own pages and workflow. ScreenshotNeo’s stated pricing is Free: 1,000 shots/month; Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; Business: $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. Only clean shots are billed; the response indicates verdict and billing headers.

7. Troubleshooting

Symptom	Likely cause	Fix
Request returns an authentication error	Missing, invalid, or incorrectly configured API credential	Check the provider’s required auth scheme and credential parameter name. Store the key in n8n credentials and verify the credential is attached to the HTTP Request node.
The screenshot service says the URL is missing or invalid	The URL expression is not mapped from the current row, or the cell is blank/malformed	Inspect the incoming item JSON, map the actual `url` property, and filter empty values before the request.
The request output has JSON but no image file	The response format is not set to File, or the provider returned an error payload	Set the HTTP Request response format to File and inspect the HTTP status/body for failed requests.
Drive says binary data is missing	The upload node expects a different field than the HTTP Request output field	Set the request output field and Drive input field to the same name, such as `data`.
Files overwrite or duplicate	Generated names collide, or a retry repeats an upload after a partial success	Add a stable row ID to filenames and define how to handle existing files. Track the upload result before retrying writeback.
Updates land on the wrong row	Row identity was lost or an index was assumed after filtering/sorting	Carry the original row number or a unique ID through every node and use that key for update.
Later rows stop after one failure	Node error behavior terminates the execution	Configure item-level error handling and route failed items to a status update, then test with a deliberately invalid URL.
Workflow slows or runs out of memory/storage	Many large binary files are retained or processed at once	Reduce batch size, add a delay, limit capture dimensions where suitable, and review n8n execution-data retention and host capacity.
Drive link cannot be opened by a teammate	The file permissions do not grant that person access	Adjust folder or file sharing according to your organization’s policy and verify access using the intended account.

8. FAQ

Can I process only newly added URLs?

Yes. Use a Sheets trigger for new rows or filter a scheduled read to pending rows, then preserve the row key for the update.

Can I keep screenshots in the spreadsheet itself?

Store a Drive or other storage link in the sheet. The screenshot response is binary file data, so a file destination is appropriate for durable storage.

Do I need Google’s Sheets API directly?

Usually not when using n8n’s built-in Google Sheets node. Google’s lower-level spreadsheets.values.get method is documented in the [Sheets API reference](https://developers.google.com/workspace/sheets/api/reference/rest/v4/spreadsheets.values/get).

Will every screenshot provider use the same request parameters?

No. Keep the workflow structure and replace the endpoint, authentication, and request options using the provider’s current API documentation.