How to Capture a Webpage Screenshot from a Google Sheet in Hindi with Make

Direct answer: Put one webpage URL in each Google Sheets row, use a Make Google Sheets trigger or search module to read that row, map its URL into a screenshot action, and send the returned image file or image URL to a destination such as Google Drive. In Make, you can use a dedicated screenshot integration or the generic HTTP module with a screenshot provider’s documented API. A plain HTTP download of a webpage is not necessarily a rendered screenshot.

The title includes “in Hindi,” but this tutorial is in English, as required. Make module names are shown in their official English form so you can find them in the interface.

1. Choose the workflow and prepare the sheet

The basic scenario is:

Google Sheets: Watch New Rows → Screenshot action or HTTP: Make a request → Google Drive: Upload a file

For new entries, use Watch New Rows. To process rows that already exist, use a search or row retrieval module and control how many rows you process in each run. Make’s Google Sheets documentation says a blank row can prevent Watch New Rows from processing later rows, so keep the watched data contiguous. See Make’s Google Sheets module documentation.

Column	Purpose	Example
URL	Page to capture; required	https://example.com/
Status	Optional processing state	Pending
Screenshot URL	Optional link to saved image	Filled by a later step
Error	Optional failure note	Filled by an error route

Use a header row, put one complete address per data row, and avoid empty rows between records. Include the scheme (https://) and check that the target page is accessible to the screenshot service. Private pages may require cookies or authentication, if the selected provider and module support them.

2. Connect Google Sheets and select a trigger

1. Create a scenario in Make and add Google Sheets.
2. Choose Watch New Rows if the scenario should respond to newly added rows. Choose a search or row-reading module when you need to process existing records or select them by a condition.
3. Create a Google connection and authorize Make to access the spreadsheet. Make’s connection instructions describe this authorization step: Create a connection in Make.
4. Select the spreadsheet and worksheet, set the header and starting point options presented by the module, and choose the number of rows to fetch per run.
5. Run the trigger once and inspect its output bundle. Confirm that the URL field contains the expected value from the row.

Module fields can change as Make updates its apps. Follow the field labels shown in your scenario rather than assuming every account presents identical configuration fields.

3. Add a screenshot action

There are two implementation routes. They are alternatives: a dedicated Make app exposes its own capture action and connection, while HTTP calls a provider API whose authentication, parameters, and response format are provider-specific.

Route A: use a dedicated screenshot app

1. Add the screenshot app’s capture action after the Google Sheets module. Make’s integration catalog lists screenshot actions, including Capture Website Screenshot for HTML to Image and webpage capture actions for GetScreenshot. See HTML to Image and Google Sheets and GetScreenshot and Google Sheets.
2. Create the connection required by that app. Some integrations require a provider account and API key; check the app’s own Make documentation and provider terms. For example, GetScreenshot’s Make documentation explains its connection setup.
3. In the action’s URL field, enable mapping and select the URL output from the Google Sheets bundle. This mapping is the key step: each row’s URL must flow into the capture action.
4. Set only options the particular app documents, such as viewport size or full-page behavior. Capture options are not universal across providers.
5. After the action runs, inspect the output to see whether it provides image data, a downloadable file, or a URL. Map that actual output to the next module.

Route B: call a screenshot API with HTTP

Make’s HTTP: Make a request module can call APIs; its description also mentions downloading webpages. To obtain an image, configure it for the screenshot provider’s documented endpoint and response behavior. Do not point HTTP at an ordinary page and assume the response is a browser screenshot. See Make’s HTTP integration and the HTTP module documentation.

1. Add HTTP: Make a request.
2. Set the method, URL, authentication, query parameters or body, and response handling exactly as the selected screenshot API documents.
3. Map the current row’s URL into that API’s URL parameter. If the API expects JSON, use its documented JSON field rather than placing the page address in the endpoint URL.
4. Run one capture and inspect whether the response is binary image data, JSON containing a link, or an error. Configure the next step for the observed response type.
5. Keep API credentials in Make’s supported connection or credential fields where available. Avoid writing secrets into spreadsheet cells that are shared with other users.

For Make’s HTTP module, a generic API request might use a provider’s endpoint and an API key, but there is no single valid request template across screenshot services. The provider’s API reference determines whether the key belongs in a header or parameter, which capture options are accepted, and whether the result is returned directly or asynchronously.

4. Save the screenshot and update the row

1. Add a destination module such as Google Drive’s file upload action or an email module that accepts an attachment or file URL.
2. Map the screenshot module’s actual file output to the destination’s file data field. If it returns only a URL, use a documented download step first when the destination requires binary file data.
3. Choose a stable filename. For example, combine a row identifier with a date. Sanitize characters that are invalid in filenames.
4. Optionally update the source row with a completion status and the Drive link or returned image URL.
5. Use a separate error route or failure-handling path to record a concise failure state. Avoid marking a row complete until the image is saved successfully.

Do not assume the output is public or permanent. Confirm the storage provider’s sharing settings and the screenshot provider’s link expiration and retention behavior before distributing a returned URL.

5. Run a small test, then schedule the scenario

1. Use a page you are permitted to capture and add one test row.
2. Run the scenario once and inspect the Google Sheets bundle, screenshot module input, screenshot output, and destination result.
3. Open the saved image and verify that it is an image of the rendered page, not HTML, a JSON error response, or a login screen.
4. Test a second row and confirm the URL mapping changes with the row.
5. Only after the flow works end to end, configure the trigger or schedule you want.

Make scheduling, operation allowances, screenshot-provider quotas, and storage limits depend on the accounts and plans selected. Check current terms in each account; the sources reviewed do not establish a universal quota or price for this workflow.

6. ScreenshotNeo alternative: one API call

If maintaining a browser setup or configuring a separate screenshot integration is inconvenient, use ScreenshotNeo from Make’s HTTP module. Configure a GET request to the API endpoint below, map the spreadsheet URL into the url query parameter, and provide your API key. See the ScreenshotNeo API documentation for the documented options and response details.

GET https://api.screenshotneo.com/v1/shot?access_key=YOUR_API_KEY&url={{mapped URL}}

In Make, use HTTP: Make a request, set the URL to https://api.screenshotneo.com/v1/shot, select the GET method, and add access_key and url as query parameters. Map the row’s URL into url. Treat the response according to the output Make shows for the request and the API documentation. ScreenshotNeo accepts the cookie or consent banner like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server gives AI agents tools for screenshots, page information, and PDFs. The free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots.

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

7. Troubleshooting

Symptom	Likely cause	What to do
Watch New Rows does not see later records	A blank row in the watched sheet can stop later rows from being processed.	Remove gaps in the watched data, check the selected worksheet and trigger starting point, then run the module again.
The screenshot action receives an empty URL	The wrong output token was mapped, the header is missing, or the row value is blank.	Inspect the trigger bundle, confirm the URL column header, and remap the URL token from the current bundle.
The HTTP step returns HTML rather than an image	The request targeted the webpage itself, or the screenshot API returns a link/JSON instead of image bytes.	Call a screenshot-rendering API endpoint and inspect its documented response format. Add a download step if it returns a URL and the next module needs a file.
401 or 403 response	Missing, invalid, or incorrectly placed credentials; the target may also restrict access.	Check the provider’s authentication instructions, key validity, required headers, and page access. Do not expose keys in a shared sheet.
400 response or invalid parameter	Wrong parameter name or value, malformed URL, or unsupported capture option.	Compare the request with the provider’s current API documentation and test with a simple public URL.
Timeout or failed capture	The page is slow, blocked, or relies on scripts or resources that do not finish promptly.	Check the target in a normal browser, use only documented wait controls, and handle failures as retryable when appropriate.
Saved file cannot be opened	An error body may have been saved with an image extension, or the response was not treated as binary data.	Inspect the response status and content type before saving. Route error responses away from file upload.
Duplicate images appear	The scenario retried after capture or storage without an idempotency check.	Use a row ID or stable URL-plus-date key to check whether the output already exists before creating another file.
Only some rows finish	A provider quota, Make allowance, storage limit, or per-run row limit may have been reached.	Check each service’s current usage and execution history, then reduce batch size or adjust scheduling within the account’s limits.

8. Reliability, performance, and cost

• Process in controlled batches. Large backlogs can run into per-run limits, provider quotas, or long execution times. Start with a small batch and increase it based on observed behavior.
• Use a failure path. Record the row identifier and error status, and retry transient failures separately. Avoid endlessly retrying invalid URLs or authentication errors.
• Prevent duplicate work. Mark rows pending, processing, complete, or failed, and make the destination filename deterministic where practical.
• Expect dynamic pages to vary. Consent dialogs, login requirements, delayed scripts, and lazy-loaded content affect what a capture service can render. Configure waits or full-page behavior only when supported by that provider.
• Measure the whole workflow. Each module can add execution time or account usage. A screenshot API may charge according to its own plan and rules; Make and storage have separate terms. Compare the total cost for your expected rows and retry rate.
• Protect captured data. A screenshot can contain personal or confidential information visible on the page. Limit sheet and destination access, and review provider data handling and retention terms.

9. Frequently asked questions

Can I capture rows that are already in the sheet?

Yes. Use a Google Sheets search or row-reading approach suited to existing data, then process results in controlled batches. A new-row trigger is intended for new records.

Does Make’s HTTP module itself render a webpage?

Do not assume so. HTTP can call an API or download a webpage; rendered screenshots require a screenshot action or a screenshot API that renders the supplied URL.

Can I email the result instead of saving it?

Yes, if the email module accepts the response as a file attachment or can access the returned image URL. Check whether the URL is accessible to the recipient and whether it expires.

Can I capture a page behind a login?

Only if the selected provider supports the required authentication or session configuration and you are authorized to access the page. Avoid putting passwords or tokens in ordinary sheet cells.

Where do I find capture settings?

Use the selected screenshot app’s Make module fields or the provider’s API documentation. Viewport, full-page, waits, and output formats vary by provider.