ZenRows

Discard the PENDING webhook signing key and keep signing with the current one. The pending key is destroyed with no undo -- starting over means another Start a key rotation -- but no delivery breaks, because the key in use does not change. Answers 204 with no body via DELETE /hmac/keys/rotate

Delete one run of a Batch job AND the results it holds. There is no undo and no trash: re-collecting the data means rerunning the job, which spends credits again. Answers 204 with no body via DELETE /jobs/{job_id}/runs/{run_id}

Stop delivering this Batch job's results to a webhook. Deliveries already made are not recalled, and results stay readable through Read a job's results. REVERSIBLE: set it again with Set a job's webhook. Answers 204 with no body via DELETE /jobs/{job_id}/webhook

Retrieve one URL through ZenRows and return its content. One request covers the whole Universal Scraper surface, because these are configurations rather than separate endpoints: `js_render` runs a headless browser, `premium_proxy` plus `proxy_country` picks a residential exit IP, `response_type=markdown|plaintext|pdf` converts the page, `screenshot`/`screenshot_fullpage` return an image, and `extract=auto`, `css_extractor`, `autoparse` and `outputs` return structured JSON instead of markup. EVERY CALL SPENDS CREDITS and the cost depends on the configuration that succeeds, so `mode=auto` (escalate only when the target needs it) is the cheapest way to fetch a protected page. A non-JSON reply comes back as `{content_type, text}`, and a PDF or screenshot as `{content_type, content_base64}`; anything over 4 MB is refused rather than truncated -- use a Batch job with a webhook for bulk. For many URLs use Create a batch job instead of calling this in a loop via GET /

Report the claim state of the connected account: its id, whether a person has taken ownership (`claimed`), whether it was created by ZenRows' anonymous agent signup (`isAgent`) and when a trial allowance ends. Claiming does not rotate the key, so this is how a long-running connection learns a human took over. It never returns an email or any secret. This is the only tool served from app.zenrows.com and it is the endpoint a pasted key would be probed against via GET /api/agent/account

The HMAC keys ZenRows signs this account's webhook deliveries with, so a receiver can verify them. These are the account's own webhook-verification secrets; they are not the API key and cannot be used to call this API via GET /hmac/keys

Page through the Batch jobs on the account, newest first. Filter by whether a job still accepts tasks (`status=open|closed`) or by `type=regular|scheduled`, and pass the previous page's `next_cursor` back as `cursor` via GET /jobs

Read one Batch job and the state of its most recent run, including `latest_run.status` (`running`, `completed`, `stopped` and `deleted` are terminal) and `latest_run.stats` (total, completed, successful, failed). Poll this, or set a webhook, to learn when a run has finished via GET /jobs/{job_id}

Page through the per-URL results of a run: each task's status, its content or the location to collect it from, and the `external_id` you set when the task was submitted so a result can be joined back to your own record. Filter with `status=successful|failed` and page with `cursor` via GET /jobs/{job_id}/results

Every run of one Batch job, newest first, with each run's stats. This is where a `run_id` comes from for Delete a run and Export a run as a ZIP via GET /jobs/{job_id}/runs

Read the plan behind the connected key: its credit allowance, the credits already used and the concurrency it is allowed. The cheapest read on this integration and the one to call before a large run, because ZenRows answers 402 once an account is out of credits and 429 AUTH008 once every concurrency slot is busy -- neither is a broken tool via GET /subscriptions/self/details

Issue a new webhook signing key alongside the current one, so a receiver can accept both while the new one is deployed. Finish a key rotation promotes it; Cancel a key rotation discards it via POST /hmac/keys/rotate

Promote the pending webhook signing key and retire the previous one. Any receiver still verifying against only the old key starts rejecting deliveries at this point, so deploy the new key first via POST /hmac/keys/rotate/finalize

Upload a CSV of URLs to run as a Batch job, for an input too large to send inline. The body is the CSV ITSELF, sent as `text/csv` -- rows carry the URLs and any per-URL columns -- and the identifier it returns goes into Create a batch job as `input_id` via POST /job_inputs

Submit a Batch job -- the supported way to fetch many URLs, because results are collected asynchronously and can be delivered to a webhook instead of returned inline. A `closed` job carries every URL up front in `tasks` (up to 10,000 per call); an `open` job is created empty and receives URLs through Add URLs to an open job until one call sets `last_batch`. `zenrows_params` applies the Fetch parameters to every task and a per-task `zenrows_params` overrides it. `type=scheduled` needs a cron from Set a job's schedule. Answers 201 under 10,000 inline tasks and 202 at or above that (or for a CSV input); the body is identical, so treat both the same via POST /jobs

Cancel the Batch job and the work still pending on it. Results already produced stay readable through Read a job's results; the job stops accepting and dispatching anything further via POST /jobs/{job_id}/cancel

Lock an open Batch job so it accepts no further tasks. Equivalent to sending `last_batch: true` on the last add, and there is no reopen: a closed job can only be rerun or copied via POST /jobs/{job_id}/close

Stop dispatching new tasks without abandoning the run, so Resume a paused run can continue it. The reversible alternative to Stop the current run via POST /jobs/{job_id}/pause

Start a new run of the same Batch job -- how a dataset is refreshed on demand. `only_failed: true` retries just the tasks that failed last time, which is the cheaper call: a rerun spends credits again for every task it dispatches via POST /jobs/{job_id}/rerun

Continue dispatching the remaining tasks of a paused run via POST /jobs/{job_id}/resume

Ask ZenRows to package a run's content as a ZIP. The export is prepared asynchronously and downloaded from the URL in the response, which is why this is the supported route for bulk content rather than reading pages through tool results via POST /jobs/{job_id}/runs/{run_id}/exports

Turn a scheduled Batch job on or off with `enabled`, without deleting the cron it holds. This is the reversible way to stop a recurring job from spending credits via POST /jobs/{job_id}/schedule/state

Abandon the run in flight. Tasks that already completed keep their results, and the remaining ones are not dispatched. Use Pause the current run instead if the run should continue later via POST /jobs/{job_id}/stop

Append up to 10,000 URLs to an OPEN Batch job. Send `last_batch: true` on the final call to close it; a later addition then answers 409, which means the job is closed rather than that the request was wrong via POST /jobs/{job_id}/tasks

Deliver a sample payload to a `url` you name, so a receiver and its signature check can be verified before a real run spends credits via POST /webhook/test

Give a `scheduled` Batch job its cron expression and the IANA timezone the cron is read in. REPLACES the whole schedule rather than merging into it, and every run it triggers spends credits via PUT /jobs/{job_id}/schedule

Have ZenRows deliver this job's results to an endpoint you control as tasks complete, instead of polling. REPLACES any webhook already on the job. Deliveries are signed with the account's HMAC keys, which List webhook signing keys returns so a receiver can verify them via PUT /jobs/{job_id}/webhook