# Screenshot a list of URLs in n8n

> An importable n8n workflow: read URLs from a Google Sheet or a webhook, take each screenshot, write the link back. Retries 429, stops on 402.

n8n workflow by Serghei Pogor, founder of CurlShot (https://curlshot.com/about/serghei-pogor). Published 16 November 2026. Page for people: https://curlshot.com/blog/n8n-screenshot-urls-from-a-sheet

Paste the workflow file from this page on an empty n8n canvas, add your CurlShot access key as a Header Auth credential, and point the Google Sheets nodes at a sheet with the columns url, image_link, expires_at, status. It sends one POST for each row and writes the returned link and its expiry back to that row. A 429, a 5xx or a lost connection is tried once more after the Retry-After wait, and a 401, 402 or 403 ends the run with an error. Each successful row uses one screenshot of your plan.

## Key facts

- The file has 14 nodes for a sheet and 13 for a webhook. The HTTP Request node asks for response_type json, so the sheet gets a link and not a file.
- The HTTP Request node of n8n does not honour Retry-After, and Retry On Fail waits at most 5 seconds. A Wait node reads the header instead, and each row is tried twice at most.
- A 401, 402 or 403 ends the run with an error that names the address. Rows saved before it keep their links, and the next run skips them.
- In a run on n8n 2.47.5 against a stand-in server, 12 rows ended as 6 links and 6 status texts, in 20 calls.
- The link a call returns expires, so the sheet stores expires_at next to it. Download the file if you need it for longer. CurlShot counts one screenshot for each successful row and none for a failed call.

## The workflow file

The file the generator on the page writes with its default settings (a Google Sheet as the source, PNG, whole page, cookie banners hidden, a 1 second pause). Paste it on an empty n8n canvas. It has 14 nodes. The webhook variant has 13: the manual trigger and the sheet read are replaced by a Webhook node, and the two Save nodes append rows.

```json
{
  "name": "CurlShot screenshots from a list of URLs",
  "nodes": [
    {
      "parameters": {},
      "id": "n8n-shot-start",
      "name": "Start",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [
        0,
        200
      ]
    },
    {
      "parameters": {
        "documentId": {
          "__rl": true,
          "mode": "id",
          "value": ""
        },
        "sheetName": {
          "__rl": true,
          "mode": "name",
          "value": "Sheet1"
        },
        "options": {}
      },
      "id": "n8n-shot-read-the-sheet",
      "name": "Read the sheet",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.7,
      "position": [
        220,
        200
      ]
    },
    {
      "parameters": {
        "mode": "runOnceForAllItems",
        "jsCode": "// Rows of the sheet that have a web address and no picture link yet.\nconst seen = new Set();\nconst rows = [];\nfor (const item of $input.all()) {\n  const url = String(item.json.url || '').trim();\n  if (!/^https?:\\/\\//i.test(url) || item.json.image_link || seen.has(url)) continue;\n  seen.add(url);\n  rows.push({ json: { url, row_number: item.json.row_number } });\n}\nreturn rows;"
      },
      "id": "n8n-shot-pick-new-rows",
      "name": "Pick new rows",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        440,
        200
      ]
    },
    {
      "parameters": {
        "batchSize": 1,
        "options": {}
      },
      "id": "n8n-shot-loop-over-items",
      "name": "Loop Over Items",
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 3,
      "position": [
        660,
        200
      ]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://curlshot.com/api/v1/screenshot",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({ url: $json.url, format: 'png', full_page: true, block_cookie_banners: true, timeout: 60, response_type: 'json' }) }}",
        "options": {
          "timeout": 90000,
          "response": {
            "response": {
              "fullResponse": true,
              "neverError": true,
              "responseFormat": "json"
            }
          }
        }
      },
      "id": "n8n-shot-capture",
      "name": "Capture",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        880,
        320
      ],
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "mode": "runOnceForEachItem",
        "jsCode": "// What the call answered, and where this row goes next.\nconst row = $('Loop Over Items').item.json;\nconst status = Number($json.statusCode) || 0;\nconst headers = $json.headers || {};\nconst body = $json.body && typeof $json.body === 'object' ? $json.body : {};\nconst mayRetry = true;\nlet route = 'fail';\nif (status === 200 && body.url) route = 'ok';\nelse if (status === 401 || status === 402 || status === 403) route = 'stop';\nelse if (mayRetry && (status === 0 || status === 429 || status >= 500)) route = 'retry';\nconst wait = Math.min(Math.max(Number(headers['retry-after']) || 0, 1), 60);\nconst code = body.error_code || (status === 200 ? 'no link in the answer' : '');\nreturn {\n  json: {\n    ...row,\n    route,\n    wait,\n    status: route === 'ok' ? 'ok' : status === 0 ? 'no answer' : ('HTTP ' + status + ' ' + code).trim(),\n    image_link: route === 'ok' ? body.url : '',\n    expires_at: body.expires_at || '',\n  },\n};"
      },
      "id": "n8n-shot-sort-the-answer",
      "name": "Sort the answer",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1100,
        320
      ]
    },
    {
      "parameters": {
        "rules": {
          "values": [
            {
              "outputKey": "ok",
              "renameOutput": true,
              "conditions": {
                "options": {
                  "caseSensitive": true,
                  "leftValue": "",
                  "typeValidation": "strict"
                },
                "combinator": "and",
                "conditions": [
                  {
                    "id": "route-0",
                    "operator": {
                      "type": "string",
                      "operation": "equals"
                    },
                    "leftValue": "={{ $json.route }}",
                    "rightValue": "ok"
                  }
                ]
              }
            },
            {
              "outputKey": "retry",
              "renameOutput": true,
              "conditions": {
                "options": {
                  "caseSensitive": true,
                  "leftValue": "",
                  "typeValidation": "strict"
                },
                "combinator": "and",
                "conditions": [
                  {
                    "id": "route-1",
                    "operator": {
                      "type": "string",
                      "operation": "equals"
                    },
                    "leftValue": "={{ $json.route }}",
                    "rightValue": "retry"
                  }
                ]
              }
            },
            {
              "outputKey": "stop",
              "renameOutput": true,
              "conditions": {
                "options": {
                  "caseSensitive": true,
                  "leftValue": "",
                  "typeValidation": "strict"
                },
                "combinator": "and",
                "conditions": [
                  {
                    "id": "route-2",
                    "operator": {
                      "type": "string",
                      "operation": "equals"
                    },
                    "leftValue": "={{ $json.route }}",
                    "rightValue": "stop"
                  }
                ]
              }
            },
            {
              "outputKey": "fail",
              "renameOutput": true,
              "conditions": {
                "options": {
                  "caseSensitive": true,
                  "leftValue": "",
                  "typeValidation": "strict"
                },
                "combinator": "and",
                "conditions": [
                  {
                    "id": "route-3",
                    "operator": {
                      "type": "string",
                      "operation": "equals"
                    },
                    "leftValue": "={{ $json.route }}",
                    "rightValue": "fail"
                  }
                ]
              }
            }
          ]
        },
        "options": {}
      },
      "id": "n8n-shot-where-next",
      "name": "Where next",
      "type": "n8n-nodes-base.switch",
      "typeVersion": 3.2,
      "position": [
        1320,
        320
      ]
    },
    {
      "parameters": {
        "operation": "update",
        "documentId": {
          "__rl": true,
          "mode": "id",
          "value": ""
        },
        "sheetName": {
          "__rl": true,
          "mode": "name",
          "value": "Sheet1"
        },
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "row_number": "={{ $json.row_number }}",
            "image_link": "={{ $json.image_link }}",
            "expires_at": "={{ $json.expires_at }}",
            "status": "ok"
          },
          "matchingColumns": [
            "row_number"
          ],
          "schema": []
        },
        "options": {}
      },
      "id": "n8n-shot-save-link",
      "name": "Save link",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.7,
      "position": [
        1560,
        120
      ]
    },
    {
      "parameters": {
        "amount": "={{ $json.wait }}",
        "unit": "seconds"
      },
      "id": "n8n-shot-wait-for-retry",
      "name": "Wait for retry",
      "type": "n8n-nodes-base.wait",
      "typeVersion": 1.1,
      "position": [
        1560,
        320
      ]
    },
    {
      "parameters": {
        "errorMessage": "={{ 'Stopped at ' + $json.url + ': ' + $json.status + '. Fix the key or the plan, then run again. Rows that already have a link are skipped.' }}"
      },
      "id": "n8n-shot-stop-and-report",
      "name": "Stop and report",
      "type": "n8n-nodes-base.stopAndError",
      "typeVersion": 1,
      "position": [
        1560,
        520
      ]
    },
    {
      "parameters": {
        "operation": "update",
        "documentId": {
          "__rl": true,
          "mode": "id",
          "value": ""
        },
        "sheetName": {
          "__rl": true,
          "mode": "name",
          "value": "Sheet1"
        },
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "row_number": "={{ $json.row_number }}",
            "status": "={{ $json.status }}"
          },
          "matchingColumns": [
            "row_number"
          ],
          "schema": []
        },
        "options": {}
      },
      "id": "n8n-shot-save-error",
      "name": "Save error",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4.7,
      "position": [
        1560,
        700
      ]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://curlshot.com/api/v1/screenshot",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({ url: $json.url, format: 'png', full_page: true, block_cookie_banners: true, timeout: 60, response_type: 'json' }) }}",
        "options": {
          "timeout": 90000,
          "response": {
            "response": {
              "fullResponse": true,
              "neverError": true,
              "responseFormat": "json"
            }
          }
        }
      },
      "id": "n8n-shot-capture-again",
      "name": "Capture again",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        1780,
        320
      ],
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "mode": "runOnceForEachItem",
        "jsCode": "// What the call answered, and where this row goes next.\nconst row = $('Loop Over Items').item.json;\nconst status = Number($json.statusCode) || 0;\nconst headers = $json.headers || {};\nconst body = $json.body && typeof $json.body === 'object' ? $json.body : {};\nconst mayRetry = false;\nlet route = 'fail';\nif (status === 200 && body.url) route = 'ok';\nelse if (status === 401 || status === 402 || status === 403) route = 'stop';\nelse if (mayRetry && (status === 0 || status === 429 || status >= 500)) route = 'retry';\nconst wait = Math.min(Math.max(Number(headers['retry-after']) || 0, 1), 60);\nconst code = body.error_code || (status === 200 ? 'no link in the answer' : '');\nreturn {\n  json: {\n    ...row,\n    route,\n    wait,\n    status: route === 'ok' ? 'ok' : status === 0 ? 'no answer' : ('HTTP ' + status + ' ' + code).trim(),\n    image_link: route === 'ok' ? body.url : '',\n    expires_at: body.expires_at || '',\n  },\n};"
      },
      "id": "n8n-shot-sort-the-second-answer",
      "name": "Sort the second answer",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        2000,
        320
      ]
    },
    {
      "parameters": {
        "amount": 1,
        "unit": "seconds"
      },
      "id": "n8n-shot-pause",
      "name": "Pause",
      "type": "n8n-nodes-base.wait",
      "typeVersion": 1.1,
      "position": [
        1780,
        120
      ]
    }
  ],
  "connections": {
    "Start": {
      "main": [
        [
          {
            "node": "Read the sheet",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Read the sheet": {
      "main": [
        [
          {
            "node": "Pick new rows",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Pick new rows": {
      "main": [
        [
          {
            "node": "Loop Over Items",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Loop Over Items": {
      "main": [
        [],
        [
          {
            "node": "Capture",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Capture": {
      "main": [
        [
          {
            "node": "Sort the answer",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Sort the answer": {
      "main": [
        [
          {
            "node": "Where next",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Where next": {
      "main": [
        [
          {
            "node": "Save link",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Wait for retry",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Stop and report",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Save error",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Wait for retry": {
      "main": [
        [
          {
            "node": "Capture again",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Capture again": {
      "main": [
        [
          {
            "node": "Sort the second answer",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Sort the second answer": {
      "main": [
        [
          {
            "node": "Where next",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Save link": {
      "main": [
        [
          {
            "node": "Pause",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Save error": {
      "main": [
        [
          {
            "node": "Pause",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Pause": {
      "main": [
        [
          {
            "node": "Loop Over Items",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {},
  "settings": {
    "executionOrder": "v1"
  },
  "active": false
}
```

## Set it up

1. **Make the sheet.** One tab with a header row: url, image_link, expires_at, status. Fill the url column with full addresses that start with http:// or https://. Leave the other three empty.
2. **Save the key as a credential.** In n8n, create a Header Auth credential with the name X-Access-Key and your access key as the value. The key never goes into the file.
3. **Paste the file on the canvas.** Copy the JSON above, click the empty n8n canvas and paste. n8n draws all the nodes and the lines between them.
4. **Pick the credential and the sheet.** Open Capture and Capture again and choose the credential. Open Read the sheet, Save link and Save error, sign in to Google, and choose the document and the tab.
5. **Run it.** Press Execute workflow. Each row that gets a link shows it in the image_link column. Run it again and the rows with a link are skipped.

## Node by node

| Node | What it does | The setting that matters |
| --- | --- | --- |
| Start | A manual trigger. Press Execute workflow and the run starts. | Swap it for a Schedule Trigger to run every night. Nothing after it changes. |
| Webhook | Starts a run when something sends a POST with a JSON body like {"urls": ["https://example.com"]}. | It answers at once with "Workflow got started", before any picture is taken, so the caller does not wait. Use the production address after you publish the workflow, not the test address. |
| Read the sheet | The Google Sheets node, Get row(s), with no filter. It returns every row, with its row_number. | The sheet needs a header row with url, image_link, expires_at, status. The row_number is what the update step matches on, so do not rename it. |
| Pick new rows | A Code node that keeps rows with an address that starts with http:// or https://, drops repeats, and drops rows that already have an image_link. For a webhook it reads the urls list of the body instead. | This is why a second run only does the rows that failed or are new. A bad line in the sheet is dropped here, not sent to the API. |
| Loop Over Items | Hands out one row at a time (batch size 1). Its loop output goes to Capture. The done output stays empty on purpose. | One row at a time means one render running at a time, so the concurrency limit is not what a run hits. |
| Capture | The HTTP Request node. One POST per row, with the address, the format and the options in a JSON body. | Three settings carry it. response_type json makes the API answer with a link, not a file. Response is set to include headers and status, with Never Error on, so a 429 arrives as an item with a status code. On Error continues, so a lost connection does not end the run. The node waits 90 s, which is the API timeout of 60 s plus 30. |
| Sort the answer | A Code node. It reads the status code and the Retry-After header and decides one of four routes: ok, retry, stop or fail. It also fills image_link, expires_at and a status text. | All the rules sit in these few lines, so a change to what counts as a retry is a change in one place. The rule table below shows them. |
| Where next | A Switch node with one output for each route. | The rules compare the route text, so each output can be read on the canvas: ok, retry, stop, fail. |
| Save link | Google Sheets, Update row. It matches on row_number and writes image_link, expires_at and the status ok. For a webhook it appends a new row with the address too. | The link is temporary. The answer carries expires_at, and the node stores it next to the link. |
| Wait for retry | A Wait node. It pauses for the seconds the previous node worked out from Retry-After. | The pause is capped at 60 seconds, because n8n keeps a wait under 65 seconds in memory and saves a longer one to the database. |
| Capture again | The same call as Capture, a second time. | It is a copy of Capture, so it has the same credential and settings. Change one, change the other. |
| Sort the second answer | The same code as Sort the answer, with retries switched off. | Its only difference is the line const mayRetry = false. After it a row can only be ok, stop or fail, so the retry loop runs once. |
| Stop and report | A Stop and Error node. It ends the run with a message that names the address and the code. | The run shows as failed in the Executions list and starts an error workflow if you set one. Rows saved before the stop keep their links. |
| Save error | Google Sheets, Update row. It writes the status text and leaves image_link empty. For a webhook it appends a row with that status. | An empty image_link means the next run picks the row up again. A failed call is free, so trying again costs nothing. |
| Pause | A Wait node that pauses 1 second before the next row. | It paces the run, the way the n8n docs suggest for rate limits. Set it to 0 in the generator on this page and the node is left out. |

## What each answer does

| The answer | Route | What the workflow does | Why |
| --- | --- | --- | --- |
| 200 and a link in the JSON | ok | Write the link, its expiry and status ok to the row. | The call is a success and uses one screenshot. |
| 200 and no link | fail | Write "HTTP 200 no link in the answer". No second call. | Asking again will not add a link. |
| 429 | retry | Wait the Retry-After seconds (at least 1, at most 60), call once more. | You sent too fast. The docs say it passes after the wait. |
| 500 and above (503 for a page that took too long) | retry | Wait the Retry-After seconds, or 1 second without one, call once more. | A temporary problem on our side or on the target site. The docs mark 500 and 503 as worth a second try. |
| No answer (the node timeout, a cut connection) | retry | Wait 1 second, call once more. | The call may not have reached the API, or the answer was lost. |
| 401, 402, 403 | stop | End the run with an error that names the address and the code. | The key, the quota or the plan is the problem, and every later row would fail the same way. Failed calls are free. |
| 400, 404, 413, 422 and the rest | fail | Write the status and the error code to the row. No second call. | The request is wrong, so the same call fails the same way. Fix the address or the options. |
| 429, a 5xx or no answer on the second call | fail | Write the status. There is no third call. | A bound on the loop, so a row can not spin forever. The row has no link, so the next run picks it up again. |

## What the run did

15 sheet rows were read, 3 were dropped (one had a link, one had no web address, one was a repeat), and 12 went through the loop. 6 got a link and 6 got a status text. 20 calls reached the stand-in server.

| What the stand-in server did | Calls and the seconds between them | What the row got |
| --- | --- | --- |
| Answers 200 with a link. | 200 | Link, expiry, status ok. |
| The first call gets 429 with Retry-After: 2. | 429 (2.1 s) → 200 | Link, expiry, status ok. |
| The first call gets 429 with no Retry-After. | 429 (1.1 s) → 200 | Link, expiry, status ok. |
| Both calls get 429 with Retry-After: 1. | 429 (1.3 s) → 429 | Status: HTTP 429 rate_limited. No link. |
| The first call gets 503 timeout, then 200. | 503 (1.1 s) → 200 | Link, expiry, status ok. |
| Both calls get 503. | 503 (1 s) → 503 | Status: HTTP 503 service_unavailable. No link. |
| The first call hangs past the node timeout (3 s in the lab), the second answers 200. | no answer (4 s) → 200 | Link, expiry, status ok. |
| The connection is cut on both calls. | cut (1.1 s) → cut | Status: no answer. No link. |
| Answers 422 invalid_options. | 422 | Status: HTTP 422 invalid_options. No link, and no second call. |
| Answers 200, but the body is HTML. | 200 (not JSON) (1 s) → 200 (not JSON) | Status: no answer. n8n could not read the body as JSON, so the row looks like a lost connection. |
| Answers 200 with JSON that has no link. | 200 (no link) | Status: HTTP 200 no link in the answer. No second call. |
| Answers 200 with a link. | 200 | Link, expiry, status ok. |

Runs that end on purpose:

| The stand-in server | Calls | Rows saved | What the run did |
| --- | --- | --- | --- |
| The second of three rows answers 402 quota_exceeded. | 2 | 1 | The run ended with the error "Stopped at <address>: HTTP 402 quota_exceeded". The first row kept its link, the third address was never called. |
| The first of two rows answers 401 access_key_invalid. | 1 | 0 | The run ended at once with the same kind of message, and the second row was never called. |

## What the first draft got wrong

- **n8n refused the first file.** Importing the first generated file failed with "Workflow structure is invalid. nodes[11].position[1] (invalid_type): Expected number, received null". The generator had been called for Capture again without the API address, so every later argument moved one place. Reading the JSON had not shown it; the import did. Fixed, and all 12 variants of the generator (sheet or webhook, three formats, with or without the pause) now import.
- **Retry On Fail was the first plan.** The first plan was the setting every node has, Retry On Fail. The n8n docs say its wait is capped at 5 seconds, its tries at 5, and that the HTTP Request node does not honour a Retry-After header. A 429 that asks for 12 seconds would be tried again too soon. The file uses a Wait node that reads the header instead.
- **A 200 that is not JSON reads as a lost connection.** With the response format set to JSON, an HTML body with status 200 made the node fail, so the row went down the "no answer" road and was called twice. It is a rare case, and the status text says "no answer", so look at the Executions list when a row says that and the site is up.

## Where it still fails

- The link in the sheet expires. The answer has an expires_at field and the workflow stores it. For a file that stays, add a step after Save link that downloads the link and uploads the file to Drive or S3.
- Rows are taken one at a time. For hundreds of addresses a run takes as long as the sum of the renders; the bulk calls of the community node, up to 100 renders in one call, are faster.
- The workflow leaves the cache off, so every run takes new pictures. Add cache true to the body if the pages change rarely; a cache hit is free.
- A page behind a login needs an authorization or cookie option in the body. The workflow does not send one.
- A row that fails stays without a link and is tried again at the next run. A page that always fails is tried every run, at no cost, until you fix or delete the row.

Each successful row uses one screenshot of your plan, and failed calls are free. The Free plan has 100 screenshots a month. See [pricing](https://curlshot.com/pricing).

## How it was tested

The workflow file was generated by the function behind this page and imported into n8n 2.47.5 with its command line (import:workflow, then execute). Five nodes were swapped for the test: the sheet read, the two sheet writes (which posted their row to the stand-in server instead) and, on the two Capture nodes, the credential (a fixed header) and the timeout (3 s, so a hanging call could be shown). A script compared every other node with the generated file: they are identical. The stand-in server answered each address the way the errors page of the docs describes, with Retry-After on the 429s. Run one used 15 sheet rows, run two a 402, run three a 401. The Google Sheets nodes, the credential and the real API were not part of the test (no Google account or access key on the lab host). What ran was the workflow file inside n8n against a stand-in server that played each answer. The webhook variant was imported but not triggered. Tested on 12 November 2026.

## Questions

### How do I screenshot a list of URLs from a Google Sheet in n8n?

Read the sheet with a Google Sheets node, loop over the rows one at a time, and send each address in a JSON body to the CurlShot screenshot endpoint with an HTTP Request node that has response_type json. Write the link in the answer back to the row with an Update row step. The workflow file on this page does all of it.

### Does n8n retry a 429 on its own?

Only if you switch on Retry On Fail, and it does not read the Retry-After header: the wait is fixed, up to 5 seconds, and the tries are capped at 5 (n8n docs, read 2026-11-12). For a longer wait, use a Wait node, as this workflow does.

### Can the list come from a webhook instead of a sheet?

Yes. Pick Webhook on the page and the file starts with a Webhook node that takes a POST body like {"urls": [...]}. It answers at once, and each result is appended as a row to the sheet. The webhook variant was imported into n8n in the test but not triggered.

### How long does the link in the sheet last?

Until the expires_at time in the answer, which the workflow writes to the expires_at column. After that the link stops working. Download the picture, or add a Drive or S3 step, if you need it for longer.

### Does this work on n8n Cloud?

Yes. It uses only nodes that ship with n8n: HTTP Request, Google Sheets, Code, Switch, Wait and Loop Over Items. The CurlShot community node does not run on n8n Cloud until n8n verifies it, so the workflow calls the API with the HTTP Request node instead.

### What does a run of this workflow cost?

One screenshot of your plan for each row that gets a link. Failed calls cost nothing, so a retry that fails is free. The Free plan of CurlShot has 100 screenshots a month and needs no card.

## Sources

1. n8n Docs, "HTTP Request node: Response, Timeout and Header Auth options": https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/ (checked 12 November 2026)
2. n8n Docs, "Handle rate limits: Retry On Fail, Loop Over Items and Wait": https://docs.n8n.io/integrations/builtin/handle-rate-limits/ (checked 12 November 2026)
3. n8n Docs, "Wait node: waits under 65 seconds keep the run in memory": https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/ (checked 12 November 2026)
4. n8n Docs, "Loop Over Items (Split in Batches): the loop and done outputs": https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.splitinbatches/ (checked 12 November 2026)
5. n8n Docs, "Work with nodes: the On Error settings": https://docs.n8n.io/build/understand-workflows/workflow-components/work-with-nodes/ (checked 12 November 2026)
6. n8n Docs, "Webhook node: Respond Immediately": https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/ (checked 12 November 2026)
7. n8n, "n8n workflow templates: how real files write the node JSON": https://n8n.io/workflows/ (checked 12 November 2026)

## Go deeper

- [n8n screenshot node](https://curlshot.com/tools/n8n-screenshot)
- [Bulk screenshots](https://curlshot.com/tools/bulk-screenshots)
- [n8n docs](https://curlshot.com/docs/integrations/n8n)
- [Errors and retries](https://curlshot.com/docs/errors)
- [Pricing](https://curlshot.com/pricing)

## Read next

- [How to screenshot a list of URLs in bulk](https://curlshot.com/blog/bulk-screenshots-list-of-urls.md): Screenshot hundreds or thousands of URLs: a queue simulator that says how long it takes, a short Node.js script, and what fails at scale.
- [Screenshot every pull request in GitHub Actions](https://curlshot.com/blog/screenshot-pull-requests-github-actions.md): Build a GitHub Actions workflow that screenshots your pull request preview on every push: pages, widths and format, retries, and a plan size.
- [15 curl errors on a screenshot call, with fixes](https://curlshot.com/blog/curl-errors-screenshot-api.md): 15 curl errors from real runs of a screenshot call: the exact message, what it means, how to check it and the fix. Paste yours to look it up.
