Zenrows MCP server: Fetch, Extract, Batch, and Browser Sessions for AI agents
| Endpoint | https://mcp.zenrows.com/mcp (streamable-http) |
|---|---|
| Registry version | 2.17.0 |
| Now | 62 tools · grade D (55) · pin ts_e1cef61dfb48e1bdd96a62af7d4433b4 · protocol 2025-06-18 |
| First / last listed | 2026-10-29 02:34 UTC / 2026-10-29 02:34 UTC |
| Grade over time | 2026-10-29: D (55), 62 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: scrape extract prepare_domain prepared_domain_status batch_create batch_status batch_wait batch_results batch_content batch_list batch_cancel batch_pause batch_resume batch_rerun batch_delete crawl_create crawl_get crawl_results crawl_content crawl_list crawl_stop crawl_wait crawl_download account_usage browser_navigate browser_close browser_go_back browser_go_forward browser_reload browser_click browser_hover browser_type browser_fill browser_select_option browser_check browser_uncheck browser_focus browser_press_key browser_scroll browser_drag browser_get_accessibility_tree browser_get_url browser_get_title browser_get_text browser_get_attribute browser_get_html browser_query_selector_all browser_screenshot browser_generate_pdf browser_wait_for_selector browser_wait_for_navigation browser_wait browser_evaluate browser_get_cookies browser_set_cookies browser_clear_cookies browser_get_local_storage browser_set_local_storage browser_clear_local_storage browser_new_tab browser_switch_tab browser_batch
scrape | Scrape any webpage and return its content using Zenrows (Fetch).
Returns full-page content (markdown/HTML/PDF/screenshot). For structured JSON
fields (products, articles, listings), the extract tool returns parsed fields
instead of a full page body.
By default the request uses automatic mode (mode=auto): Zenrows adds JS rendering
or premium proxies per page only when a plain request does not ret params: url*, js_render, premium_proxy, proxy_country, response_type, autoparse, css_extractor, wait_for, wait, js_instructions, outputs, screenshot, screenshot_fullpage, screenshot_selector |
extract | Extract structured data from a webpage via Zenrows.
Returns JSON fields (products, articles, listings) in "data" rather than a full
page body. Set include_html to also get the page HTML.
Modes:
- auto (default): extract=auto, site-tailored Extract (currently free,
billing may apply later). Works on any prepared domain, with any API key.
Error REQS007 says why in "reason":
- domain_not_prepa params: url*, mode, css_extractor, js_render, premium_proxy, proxy_country, mode_auto, wait_for, wait, fallback_autoparse, include_html |
prepare_domain | Prepare a domain so extract (mode=auto) works on it.
Use this when extract returns error REQS007 with reason domain_not_prepared. Send the
domain (the host, e.g. shop.example.com; a leading www. is dropped, and each host is
prepared separately) and 1 to 5 example URLs of real pages you want extracted. One works;
we recommend 3 or more of the same page type, so pass 3 or more when you can, up to 5 params: domain*, example_urls*, idempotency_key |
prepared_domain_status | Check a domain submitted with prepare_domain, and the account's monthly allowance.
Returns status (preparing, ready or failed), state (the current step), roles (one per page
kind), a failure code and detail when it failed, the allowance (used, limit, remaining) and
"next": what to do now. Poll about every 30 seconds; preparation takes a few minutes. Call
extract again once status is "ready". Cost params: domain* |
batch_create | Submit a Batch job: many URLs scraped asynchronously in the cloud (Zenrows Batch API). Suited to large URL lists; scrape and extract handle single pages. Not the same as browser_batch.
Tasks use automatic mode (mode=auto) by default: Zenrows enables JS rendering and premium proxies only on the pages that need them. Pass just the URLs. Set js_render or premium_proxy (job-level, or per task) only t params: tasks, urls, js_render, premium_proxy, mode_auto, proxy_country, response_type, zenrows_params, idempotency_key, wait, wait_timeout, wait_timeout_ms |
batch_status | Get a Batch job's latest run: job_id, run_id, status (pending, running, completed, stopped, failed), stats (total, completed, successful, failed) and the job.
A failed run answers ok:false with error.code BATCH_INSUFFICIENT_CREDITS, BATCH_KEY_CAP_REACHED, AUTH_INVALID (subscription_inactive) or BATCH_RUN_FAILED, error.server_code (the failure_reason) and failure_detail; batch_rerun recovers it on params: job_id* |
batch_wait | Poll a Batch job until its run ends (completed, stopped or failed) or pauses, and return its status and stats like batch_status. If the wait runs out first, it returns the current state with ok:true, timed_out:true and a note: call batch_wait again. A paused run returns at once with paused:true (it does not move until batch_resume). A failed run answers ok:false with error.code and server_code (in params: job_id*, timeout, timeout_ms |
batch_results | List a Batch run's result rows, a page at a time: up to limit rows (default 100, max 1000) and next_cursor. Pass next_cursor back as cursor to continue; it is null once every row was read.
Each row has task_id, external_id, url, metadata, status (successful, failed, pending, processing, expired), type, result_url when successful, and error when failed. A result_url is presigned and expires after params: job_id*, run_id, status, cursor, limit |
batch_content | Read one Batch task's stored result, by job_id and task_id (from batch_results). A text result (HTML, Markdown, plain text, JSON) comes back inline, cut to max_chars (default 20000); a final note says when it was cut. A binary result (a PDF) is not inlined: the reply gives its result_url, presigned for 2 hours. Finding that URL reads the run's results; on a large run one call may run out of time f params: job_id*, task_id*, run_id, max_chars, lookup_cursor |
batch_list | List this account's Batch jobs, newest first, each with its latest run's status and stats. Filter by status (open or closed) and type (regular or scheduled). Pass next_cursor as cursor for the next page; a page can hold fewer than limit jobs while next_cursor is still set, so keep paging until it is null. Deleted jobs are not listed. params: status, type, cursor, limit |
batch_cancel | Stop a Batch job's current run for good. No task still waiting is started or billed; tasks already in flight finish (and bill). Results so far stay readable with batch_results. Tasks that never started stay pending: batch_rerun (default failed and pending) runs them later. Idempotent: a run that already ended answers with its final status and already_ended:true. To halt without ending the run, use params: job_id* |
batch_pause | Pause a Batch job's current run: it picks up no new tasks until batch_resume. Tasks already in flight still finish and bill; for a hard cost stop use batch_cancel. A paused run still counts as an active job. Idempotent; a run that already ended answers with its final status and already_ended:true. params: job_id* |
batch_resume | Resume a paused Batch run: it picks up its remaining tasks again, billed as they finish. Idempotent on a run that is not paused; a run that already ended answers with its final status and already_ended:true. Needs credits: BATCH_INSUFFICIENT_CREDITS or BATCH_KEY_CAP_REACHED otherwise. params: job_id* |
batch_rerun | Start a new run of a Batch job whose latest run ended (completed, stopped or failed). By default it reruns only the tasks that failed or never started (status ["failed", "pending"]), and carries the others' results over: the recovery after a run that failed on credits or was cancelled. Pass status to pick other task statuses, or full:true to scrape every task again. Rerun tasks are billed like new params: job_id*, status, full, idempotency_key |
batch_delete | Delete a Batch job with all its runs and results, for good. A run in flight stops picking up tasks at once, and the job frees its active-job slot. The job reads as not found right away; storage is cleaned up in the background. Idempotent. To keep the results, use batch_cancel instead. params: job_id* |
crawl_create | Start a crawl from one URL (Zenrows Crawl API). Crawl follows the links in each page's HTML up to depth hops (no depth limit when depth is omitted), keeps the URLs that match include_patterns / exclude_patterns, and stays on the start URL's registrable domain (subdomains count).
Use crawl when you have one start page (a listing, category, blog index) and need
the URLs behind it, optionally with e params: url*, depth, max_items, max_pages, include_patterns, exclude_patterns, output_format, discovery, idempotency_key |
crawl_get | Get a crawl and one page of the URLs it kept: crawl_id, status (running, completed, stopped, failed), the crawl (with coverage: pages_fetched, pages_failed, items_found), results and next_cursor.
completed with stop_reason max_items / max_pages means a limit ended it; stopped with stop_reason user means crawl_stop ended it; stopped with no stop_reason and error.code insufficient_credits or api_ke params: crawl_id*, cursor, limit |
crawl_results | List the URLs a crawl kept, in the order it kept them, following the API's pages up to limit.
Each result has url and, when the crawl has output_format, content_status (pending, fetched, failed) and, once fetched, content_url: pass it to crawl_content as content.
While the crawl runs the list is partial (partial=true): call again later with the returned next_cursor to get only the URLs kept sinc params: crawl_id*, cursor, limit |
crawl_content | Read the stored page of one URL a crawl kept, in the crawl's output_format. Works only for crawls created with an output_format, and only for results whose content_status is fetched.
Pass crawl_id and content_id: a content id, or content_url from a crawl_results row. Returns the page
as stored — raw HTML for output_format "html", Markdown for "markdown" — cut to max_chars (default
20000); a final params: crawl_id*, content_id*, max_chars |
crawl_list | List this account's crawls, newest first, with status and coverage (no results). Pass next_cursor as cursor for the next page; next_cursor is absent on the last page. params: cursor, limit |
crawl_stop | Stop a running crawl. No page still waiting is fetched or billed; pages already in flight finish. The URLs kept so far stay readable with crawl_results. A stopped crawl cannot resume.
Idempotent: a crawl that already ended answers with its final status. A 429, 502, 503 or 504 is retried up to 3 times, waiting at most 50 seconds in all; a 503 crawl_busy means the stop was not saved yet, and if it params: crawl_id* |
crawl_wait | Poll a crawl until it ends (completed, stopped, or failed) and return its status, its counts and the first 20 URLs (first_urls). For every result, call crawl_download (one file) or crawl_results (pages). A crawl that ends completed with no results and no error finished; it is not a failure (see crawl_get). If the wait runs out first, it returns the crawl with status running and a note: call crawl_ params: crawl_id*, timeout |
crawl_download | Save every result of a crawl to one local file, as JSON lines: url, content_status and, once fetched, content (the page). Returns the file's path and line count, not the results, so a crawl of any size costs one small reply. Read the file with your own tools.
The file goes to path when given (a relative path inside ~/.zenrows/crawls; an absolute path or one that leaves that folder fails with INVA params: crawl_id*, path, overwrite |
account_usage | Read the current plan's credit allowance and how much of it is spent.
Useful before a large batch, or after a 402 / AUTH004, to see whether the account has
credits left and when the allowance renews. The call is free and does not use a
concurrency slot.
Credit costs per request: 1 basic, 5 js_render, 10 premium_proxy, 25 both.
AUTH004 ("usage exceeded") means this allowance is spent until it re params: none |
browser_navigate | Open a Zenrows Browser Sessions session and navigate to a URL.
This is the entry point for all browser automation. It creates a new session backed by
Zenrows' hosted browser infrastructure and navigates to the given URL in one step.
Returns a session_id that every other browser_* tool takes. The session holds one
concurrency slot until browser_close closes it.
When to use options:
- proxy_count params: url*, proxy_country, proxy_region |
browser_close | Close a browser session and free all associated resources, including the concurrency slot it holds. params: session_id* |
browser_go_back | Navigate back to the previous page in the browser history. params: session_id* |
browser_go_forward | Navigate forward to the next page in the browser history. params: session_id* |
browser_reload | Reload the current page of a browser session. params: session_id* |
browser_click | Click an element on the page using a CSS selector. params: session_id*, selector* |
browser_hover | Move the mouse cursor over an element to trigger hover effects. params: session_id*, selector* |
browser_type | Type text into an input element. Appends to existing content unless clear_first is set. params: session_id*, selector*, text*, clear_first |
browser_fill | Clear an input field and set its value, replacing what was there (browser_type appends instead). params: session_id*, selector*, value* |
browser_select_option | Select an option from a <select> dropdown element. params: session_id*, selector*, value* |
browser_check | Check a checkbox or radio button. params: session_id*, selector* |
browser_uncheck | Uncheck a checkbox, found by CSS selector, in a browser session. params: session_id*, selector* |
browser_focus | Move focus to an element, triggering focus-dependent UI changes. params: session_id*, selector* |
browser_press_key | Press a keyboard key. Examples: "Enter", "Tab", "Escape", "ArrowDown", "Control+a". params: session_id*, key* |
browser_scroll | Scroll the page in a given direction. params: session_id*, direction*, distance |
browser_drag | Drag an element from its current position to a target element. params: session_id*, source_selector*, target_selector* |
browser_get_accessibility_tree | Get the ARIA accessibility tree of the current page as readable text.
Shows the page structure and the selectors needed to interact with elements, in
fewer tokens than a screenshot.
The tree shows all interactive elements (buttons, inputs, links) with their roles,
labels, and states — everything needed to drive browser interactions. params: session_id* |
browser_get_url | Get the current URL of the browser session. params: session_id* |
browser_get_title | Get the title of the current page. params: session_id* |
browser_get_text | Get the visible text content of an element or the entire page body. params: session_id*, selector |
browser_get_attribute | Get the value of a specific attribute on an element. params: session_id*, selector*, attribute* |
browser_get_html | Get the HTML source of an element or the full page. params: session_id*, selector |
browser_query_selector_all | Find all elements matching a CSS selector and return their text, HTML, and attributes. params: session_id*, selector* |
browser_screenshot | Take a screenshot of the current page or a specific element. Use for visual verification or when the accessibility tree is not sufficient. params: session_id*, full_page, selector |
browser_generate_pdf | Render the current page as a PDF document. params: session_id*, print_background, landscape, scale |
browser_wait_for_selector | Wait until an element matching the CSS selector is stable in the DOM. Set visible=true to also require the element to be visible (not hidden). params: session_id*, selector*, visible |
browser_wait_for_navigation | Wait for the page to navigate to a new URL. It waits for the next navigation event, so a navigation that already finished is not seen and the call waits until timeout_ms. Pages that update without changing URL (AJAX/SPA) fire no navigation event. Optional timeout_ms (default 30000ms). params: session_id*, timeout_ms |
browser_wait | Wait for a fixed duration. browser_wait_for_selector waits only until an element appears. params: session_id*, ms* |
browser_evaluate | Execute JavaScript in the browser context and return the result. The script can change or delete the session's page state, such as cookies, storage and form data. params: session_id*, script* |
browser_get_cookies | Get all cookies for the current page. params: session_id* |
browser_set_cookies | Set one or more cookies in the browser session. A cookie with the same name, domain and path replaces the existing one. params: session_id*, cookies* |
browser_clear_cookies | Clear all cookies for the current browser session. params: session_id* |
browser_get_local_storage | Read one localStorage value in the current page context. params: session_id*, key* |
browser_set_local_storage | Write one localStorage value in the current page context. An existing value under the same key is replaced. params: session_id*, key*, value* |
browser_clear_local_storage | Delete every localStorage entry in the current page context. params: session_id* |
browser_new_tab | Open a new browser tab. Returns a tab_id to use with browser_switch_tab. params: session_id*, url |
browser_switch_tab | Switch focus to a different browser tab. params: session_id*, tab_id* |
browser_batch | Execute a sequence of browser actions in a single call against an existing session.
Use this when you already know the full sequence of steps — it reduces round trips and
is faster than calling each tool individually.
Actions run sequentially and stop at the first failure unless stop_on_error is false.
Each step result is returned in the results array at the same index.
Note: screenshots in bat params: session_id*, actions*, stop_on_error |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.