How to Pass a URL with Query Parameters to a Screenshot API in Zapier

In Zapier, put the screenshot service’s API endpoint in the request URL field. Add a separate query parameter named url and map the complete page URL into its value, including that page’s own query string. Zapier will encode and append the parameter. The endpoint is where the request goes; the url value tells the screenshot API which page to capture.

For example, the target page might be https://example.com/search?q=red+shoes&page=2. Put that entire string in the API’s url parameter value. Do not put the target page URL in the request URL field in place of the API endpoint.

1. Choose the right Zapier request action

Use the action that fits your workflow and the screenshot provider’s API contract:

API by Zapier – API Request: supports an HTTP method, endpoint URL, query string parameters, headers, and body. Zapier says parameters in its dedicated query string fields are URL-encoded and appended. It also warns that parameters placed in the URL field may be ignored. The current Zapier documentation describes API Request as beta and requires a paid account; check current availability for your account.
Webhooks by Zapier: can send webhook requests with payload types such as Form (URL-encoded), JSON, XML, and Raw. Zapier recommends keeping URL parameters out of the URL field and putting them in the Data fields. Choose the payload type required by the screenshot API.

Zapier’s interface and availability can change. Follow the action’s current field labels and the screenshot provider’s current documentation.

2. Configure a GET request with query parameters

Add an API Request or webhook action to your Zap.
Choose GET, if the screenshot provider documents GET for the options you need.
Set the request URL to the provider’s screenshot API endpoint, for example https://api.screenshotneo.com/v1/shot.
In the dedicated query string parameters area, add access_key with your ScreenshotNeo API key and url with the mapped field containing the complete page URL. Add any other options as separate documented parameters.
Configure authentication and headers according to the provider’s documentation. Avoid exposing a production key in a URL if the provider supports a safer authentication method.
Test the action and inspect the response before using it in later Zap steps.

ScreenshotNeo’s endpoint accepts a GET request. Its parameter names are compatible with the names used by other screenshot APIs, which can simplify a provider switch. See the ScreenshotNeo API documentation for current details.

Example Zap field mapping

Zapier field	Value	Purpose
Request URL	`https://api.screenshotneo.com/v1/shot`	Screenshot API endpoint
Query parameter: `access_key`	Your API key	ScreenshotNeo authentication
Query parameter: `url`	Mapped full target URL	Page the API captures
Query parameter: `format`	For example, `webp`, if supported by your plan and current API docs	Optional output setting; use only documented options

The field called url contains data. It is not the URL of the API action itself. If your chosen Zapier action offers a parameter name and value as separate inputs, keep them separate and map the trigger field directly into the value.

3. Preserve the target page’s own query string

Suppose a trigger provides this page URL:

https://store.example/products?sku=A%2F17&campaign=spring&ref=zapier

Map the entire URL into the screenshot API’s url parameter. Do not split the target’s sku, campaign, or ref values into top-level screenshot API parameters unless the provider explicitly documents that pattern.

Zapier constructs the outer request query from its parameter fields. That outer query carries the target page URL as one encoded parameter value. The screenshot service then interprets the value as the page to open. Avoid manually joining nested query strings or pre-encoding the mapped value unless the provider’s instructions require it; otherwise, you can end up with double encoding or a changed target URL.

Test with a representative URL containing ?, &, spaces, and percent-encoded characters. Confirm that the captured page reflects the intended query values.

4. Use POST JSON when the provider requires it

Some screenshot APIs accept a JSON body instead of query parameters, or expose advanced options only through POST. If the provider documents POST JSON:

Select POST.
Use the documented endpoint.
Set the content type to application/json, if the action does not set it automatically.
Map the full target page URL to the exact JSON field the provider specifies.
Map additional options using the documented field names, casing, types, and nesting.
Test and inspect both the HTTP response and the returned image or job information.

Do not assume that GET and POST accept the same options. A reviewed screenshot API reference, for example, documents basic capture parameters with GET or in a POST JSON body and reserves some advanced options for POST. That is provider-specific, not a universal rule.

5. Authentication and response handling

Use the authentication method supported by both Zapier and the screenshot API. API by Zapier documents OAuth2, API keys in headers, API keys as query parameters, and unauthenticated requests. Zapier’s guidance describes credential storage differently between API Request and Webhooks, so check where your selected action keeps credentials and restrict access to the Zap accordingly.

After the test step, check:

Whether the request succeeded and the provider returned the expected response type.
Whether the screenshot is returned as binary data, a URL, or job information that needs a follow-up step.
Whether later Zap steps can consume that response directly. If the API returns a URL or asynchronous job identifier, use the provider’s documented follow-up flow.
Whether the image shows the right page state, including the target URL’s query-dependent content.

A successful HTTP response does not by itself prove the intended page was captured. Check the output and any status fields the provider documents.

6. Runnable request examples

These examples call ScreenshotNeo’s GET endpoint. Replace the placeholder API key and target URL. The page URL contains its own query parameters; each client encodes it as the value of the outer url parameter.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode 'url=https://example.com/search?q=red+shoes&page=2' \
  -o shot.webp

Python

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={
        "access_key": "YOUR_API_KEY",
        "url": "https://example.com/search?q=red+shoes&page=2",
    },
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://example.com/search?q=red+shoes&page=2',
});
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));

In a Zap, map the same values through the action fields instead of assembling a URL string yourself. The request examples are for ScreenshotNeo; other providers may require different endpoints, field names, authentication, and response handling. See the API documentation.

7. Troubleshooting

Symptom	Likely cause	Fix
The request reaches the wrong URL or has no parameters	Parameters were entered in the API Request URL field.	Put them in the dedicated Query string parameters fields. Zapier warns that URL-field parameters may be ignored.
The capture opens the wrong page or loses filters	The mapped `url` value omitted part of the target URL, or the target query was split into outer API parameters.	Map the entire page URL as one `url` value and inspect it in the test input.
Values contain unexpected `%25` sequences or no longer match	The target was encoded before Zapier encoded the outer parameter, causing double encoding.	Map the original full URL and let Zapier encode it, unless the API documentation explicitly calls for pre-encoding.
Authentication fails	The key is missing, mapped to the wrong field, expired, or sent using an unsupported mechanism.	Check the provider’s authentication docs and the action’s header, connection, or query fields. Use the provider’s exact key name.
The action returns an error for an option	The option name, value type, or HTTP method does not match the provider contract.	Check casing and types; try the documented method. Some options may be POST-only.
The Zap step succeeds but the next step cannot use the output	The response may be binary, a URL, or an asynchronous job result rather than the format the next action expects.	Inspect the returned fields and follow the provider’s response or job workflow; configure the next step for that output.
The screenshot is blank, blocked, or incomplete	The page may need time to render, may block automated requests, or may depend on a specific query value or session.	Verify the target URL in a browser, check provider-supported wait and access options, and inspect any page or capture status fields.

8. Performance, reliability, and cost

Keep the request payload simple: mapping one complete target URL reduces mistakes with nested query strings.
Set timeouts thoughtfully: page rendering can take longer than a simple API lookup. Use the request action’s available timeout settings and the provider’s guidance.
Plan for dynamic pages: query-driven pages may load content after the initial HTML. Use documented wait options when available, and avoid adding long waits without a page-specific reason.
Make retries safe: retries can create repeated captures. Check whether the provider bills requests, cache hits, or unsuccessful outcomes, and use its documented cache or idempotency controls where available.
Estimate cost from the provider’s terms: do not assume all screenshot APIs bill the same way. Include test runs, retries, and scheduled Zap frequency in your estimate.

ScreenshotNeo bills only clean shots. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing; each response includes X-Page-Verdict and X-Billed headers to say what happened. It offers caching with a TTL you choose and asynchronous jobs with signed webhooks. Plans are Free with 1,000 shots/month and no card; Starter $5 for 3,000; Growth $15 for 15,000; Pro $39 for 60,000; Scale $99 for 250,000; and Business $249 for 1,000,000. Yearly billing gives two months free. Every feature is on every plan.

Or skip the browser setup

Use ScreenshotNeo’s API endpoint in Zapier and map your page URL to its url parameter, following the API documentation. For example, in a request client:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode 'url=https://example.com/search?q=red+shoes&page=2' -o shot.webp

ScreenshotNeo accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Learn about ScreenshotNeo or sign up free.

FAQ

Should I encode the target page URL before mapping it?

Usually, no. Map the full URL and let Zapier encode the outer query parameter. Pre-encoding can cause double encoding; follow the screenshot provider’s instructions if it specifies otherwise.

Can I put screenshot options in the target page URL?

No. The target URL describes the page to open. Screenshot options belong in the screenshot API request as their own documented parameters or JSON fields.

Does every screenshot API accept GET?

No. Use the method and parameter placement in that provider’s documentation. Some expose options only through POST JSON.

Only if the screenshot service supports the required authentication or session setup and its terms allow the capture. Check its documentation for supported headers, cookies, and access restrictions.

Sources

Zapier: Create an API Request action — query parameter fields, URL encoding, URL-field warning, and test responses.
Zapier: Send webhooks in Zap workflows — data fields and payload types.
Zapier: Send API requests in Zap workflows — methods, authentication, testing, and availability details.
Zapier: Ways to make API requests in Zapier — request action and credential comparison.
ScreenshotNeo API documentation — endpoint and current API parameters.