io.github.ZenRows/zenrows-mcp

Tools

• 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 renews at the end of the billing period (period_ends_at in this tool's response). Plans and credit options are described at https://www.zenrows.com/pricing. AUTH006 is the concurrency limit, not a credit limit. AUTH014 (Batch: api_key_cap_reached) means this API key hit one of its own credit caps while the account still has credits; other keys keep working. The response's api_key.caps lists the calling key's caps: window, credits, used_credits, remaining_credits, resets_at, and unavailable (usage could not be read). Caps are managed at https://app.zenrows.com/settings/api-keys.

  shallow
• batch_cancel

  Stop an in-flight Batch job run (POST /jobs/:id/stop).

  shallow
• batch_create

  Submit a cloud Batch job that fans out many URLs asynchronously (Zenrows Batch API). NOT the same as browser_batch — this hits https://async.api.zenrows.com/v1 with X-API-Key. Suited to large URL lists; scrape and extract handle single pages. Tasks use automatic mode (mode=auto) by default: Zenrows enables JS rendering and premium proxies only on the pages that need them, and charges only for the configuration that succeeds. Pass just the URLs. Set js_render or premium_proxy (job-level or in a task's zenrows_params) only to force a fixed configuration; that turns automatic mode off for the affected tasks and bills them at that configuration's cost. Returns job_id + latest_run.status/stats. batch_status and batch_wait report progress; batch_results lists the results. If you get BATCH_ACCESS_DENIED, Batch is not enabled for this account or API key.

  shallow
• batch_results

  List result rows for a Batch job (cursor-paginated server-side; returns the full list). Each row may include task_id, external_id, status, and a short-lived result_url for the body. Download result_url soon — presigned links expire.

  shallow
• batch_status

  Get status and stats for a Zenrows Batch job (latest_run.status + latest_run.stats).

  shallow
• batch_wait

  Poll batch_status until the job reaches a terminal state (completed, failed, stopped, or deleted). A run that hits an API key credit cap ends as failed with failure_reason api_key_cap_reached.

  shallow
• 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 batch results are returned as base64 strings inside the JSON; browser_screenshot returns them as images.

  shallow
• browser_check

  Check a checkbox or radio button.

  shallow
• browser_clear_cookies

  Clear all cookies for the current browser session.

  shallow
• browser_click

  Click an element on the page using a CSS selector.

  shallow
• browser_close

  Close a browser session and free all associated resources, including the concurrency slot it holds.

  shallow
• browser_drag

  Drag an element from its current position to a target element.

  shallow
• browser_evaluate

  Execute JavaScript in the browser context and return the result.

  shallow
• browser_fill

  Clear an input field and set its value, replacing what was there (browser_type appends instead).

  shallow
• browser_focus

  Move focus to an element, triggering focus-dependent UI changes.

  shallow
• browser_generate_pdf

  Render the current page as a PDF document.

  shallow
• 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.

  shallow
• browser_get_attribute

  Get the value of a specific attribute on an element.

  shallow
• browser_get_cookies

  Get all cookies for the current page.

  shallow
• browser_get_html

  Get the HTML source of an element or the full page.

  shallow
• browser_get_text

  Get the visible text content of an element or the entire page body.

  shallow
• browser_get_title

  Get the title of the current page.

  shallow
• browser_get_url

  Get the current URL of the browser session.

  shallow
• browser_go_back

  Navigate back to the previous page in the browser history.

  shallow
• browser_go_forward

  Navigate forward to the next page in the browser history.

  shallow
• browser_hover

  Move the mouse cursor over an element to trigger hover effects.

  shallow
• browser_local_storage

  Read, write, or clear localStorage in the current page context.

  shallow
• 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_country: geo-restricted content (ISO 3166-1 alpha-2, e.g. "US", "DE") - proxy_region: world region for geo-targeted proxy (eu, na, ap, sa, af, me)

  shallow
• browser_new_tab

  Open a new browser tab. Returns a tab_id to use with browser_switch_tab.

  shallow
• browser_press_key

  Press a keyboard key. Examples: "Enter", "Tab", "Escape", "ArrowDown", "Control+a".

  shallow
• browser_query_selector_all

  Find all elements matching a CSS selector and return their text, HTML, and attributes.

  shallow
• browser_reload

  Reload the current page of a browser session.

  shallow
• 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.

  shallow
• browser_scroll

  Scroll the page in a given direction.

  shallow
• browser_select_option

  Select an option from a <select> dropdown element.

  shallow
• browser_set_cookies

  Set one or more cookies in the browser session.

  shallow
• browser_switch_tab

  Switch focus to a different browser tab.

  shallow
• browser_type

  Type text into an input element. Appends to existing content unless clear_first is set.

  shallow
• browser_uncheck

  Uncheck a checkbox, found by CSS selector, in a browser session.

  shallow
• browser_wait

  Wait for a fixed duration. browser_wait_for_selector waits only until an element appears.

  shallow
• 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).

  shallow
• 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).

  shallow
• 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 note says when it was cut. To read a page the crawl did not store, use scrape on its URL instead.

  shallow
• 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 each page's HTML. For a single page, use scrape. Each page fetched is billed as one scrape on this account; max_pages bounds the cost (default 100), max_items bounds how many URLs are kept (default 100). Without depth, the crawl keeps following links until max_pages or max_items stops it or nothing is left to open, so set max_pages to what you are willing to spend. The start page itself is never a result, but its fetch is billed: a crawl whose include_patterns / exclude_patterns match nothing still costs that one scrape. A crawl whose pages held nothing new to follow (no link, only links to other sites, or only links the patterns reject) ends completed with no results and no error. When patterns are set, check them against the URLs the start page links to. Set output_format "html" or "markdown" to also store each kept URL's page, then read it with crawl_content. Returns crawl_id, status and the crawl (with coverage) at once; the crawl runs asynchronously. Call crawl_wait, then crawl_results. Set idempotency_key to make a retry safe: the same key returns the crawl the first request created instead of starting another. CRAWL_NOT_ENABLED: Crawl is not enabled for this account; do not retry. CRAWL_TOO_MANY_CRAWLS: the account has reached its limit of active jobs (3 by default), shared with its Batch jobs; retry after retry_after seconds.

  shallow
• 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 INVALID_PATH), else ~/.zenrows/crawls/<crawl_id>.jsonl. An existing file is kept and the call fails with FILE_EXISTS unless overwrite is true. On a running crawl the file holds only what was kept so far: download again once crawl_wait says it ended. After crawl_stop, pages in flight can still add lines for up to 10 minutes: the reply says so with partial: true. On the hosted server no file is written: the reply gives the download URL and a command to run where your API key is set.

  shallow
• 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_key_cap_reached means the account ran out of credits or the API key hit a credit cap (the URLs kept before that stay readable); completed with no results and no error means the crawl's pages held nothing new to follow; when include_patterns / exclude_patterns are set, check them against the URLs the start page links to. failed carries error.code and error.detail: seed_unreachable means the start URL could not be fetched or returned an empty page; no_items_found means the crawl read the start page but found no data it could use, so it had nothing to follow; start from a listing or product page. A failed crawl, and a stopped one with an error, answer ok: false: error.code is CRAWL_INSUFFICIENT_CREDITS or CRAWL_KEY_CAP_REACHED (the codes crawl_create gets on a 402) when credits ended it, failed or stopped, else CRAWL_FAILED; error.server_code is the crawl's error.code. Pass next_cursor as cursor for the next page; while the crawl runs, next_cursor is never null. To read many pages at once, use crawl_results.

  shallow
• 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.

  shallow
• 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 since. A stopped crawl can still add URLs from pages fetched before the stop for up to 10 minutes, so next_cursor stays set during that window: call again later. next_cursor is null once the crawl ended and every URL was read.

  shallow
• 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 persists, CRAWL_BUSY says when to call again. Pages in flight still finish, so coverage and results can keep growing for up to 10 minutes after the stop; read them with crawl_get and crawl_results.

  shallow
• 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_wait again. A call that carries a progressToken gets a progress notification after each poll, with the status and counts.

  shallow
• extract

  Extract structured data from a webpage via Zenrows. Returns JSON fields (products, articles, listings) rather than a full page body. Modes: - auto (default): extract=auto, site-tailored Extract (currently free, billing may apply later). Works on any domain Zenrows has prepared, with any API key; falls back to autoparse when the domain isn't prepared yet (REQS007) - autoparse: general-purpose structured JSON on any domain - css: css_extractor with an explicit selector map Requests use automatic mode (mode=auto) by default: Zenrows enables JS rendering and premium proxies only when the site needs them, and charges only for the configuration that succeeds. Pass just the URL. Set js_render or premium_proxy only to force a fixed configuration; that turns automatic mode off and bills every request at that configuration's cost. Check "empty" in the result: true means no field came back with a value. "noDataExtracted": true means Extract processed the page and found nothing to extract (not charged); retrying the same request returns the same answer. Full-page markdown, HTML and screenshots come from scrape.

  shallow
• 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 return the page, and charges only for the configuration that succeeds. Pass just the URL. Set js_render or premium_proxy only to force a fixed configuration. Doing so switches off automatic mode, and every request is billed at that configuration's cost (premium_proxy with js_render is 25x a basic request). Examples: Default: { url: "https://example.com" } Geo: { url: "https://example.com", proxy_country: "US" } Forced: { url: "https://spa.com", js_render: true }

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/3ee0a3ec-bcd5-414f-90e5-bce43d3f3380/badge.svg)](https://vouch.tools/servers/3ee0a3ec-bcd5-414f-90e5-bce43d3f3380)