Scrapfly

Click an element in the active cloud browser session. Requires a `uid` obtained from `take_snapshot` output — uids are stable for that snapshot only. Typical flow: take_snapshot → locate element by label/text → click(uid). After the click, the page may navigate or reveal new elements; take another snapshot before your next action if the DOM likely changed.

Close the cloud-browser session and release its resources. Call this ONLY when the user explicitly asks to end / close / stop / "we're done". When a task finishes normally, leave the session open — the user has a dedicated UI control for closing and may keep going in a follow-up turn.

Inspect files that have been downloaded during the current browser session (e.g. after clicking a link that triggered a download, or submitting a form that returned an attachment). Without `filename`, returns metadata for every captured download. With `filename`, returns the file's bytes base64-encoded. Only relevant when a download was triggered inside the session — for fetching a file whose URL you already know, use `web_get_page` / `web_scrape` instead.

Run JavaScript in the active cloud-browser session and return its value. Equivalent to `evaluate_script`; prefer `evaluate_script` in new code. Reads only — do NOT use for clicking/filling.

Navigate the active cloud-browser session to a new URL. Re-uses the same browser (cookies, storage, session state preserved) and refreshes the WebMCP tool list because page-registered tools are scoped to the current document. Returns a fresh snapshot. Use this instead of opening a new session when you want to stay signed in or keep context across URLs.

Start a stateful real-browser session at a URL. Use this when the task requires *interaction* with a page — the user said "open", "go to", "navigate to", "log in", or the work needs clicking, form filling, or multi-step navigation. Returns the initial accessibility snapshot plus the page's registered WebMCP tools. Do NOT use this for a plain "download <url>" or "fetch <url>" where the URL already points at the asset and no interaction is needed — use `web_get_page` (simple) or `web_scrape` (with options) instead. Those are cheaper and faster. Once a session is open, the FULL set of CDP-backe…

PageSpeed Insights-style lab run: cold-cache reload with mobile throttling (Moto G4 + slow 4G + 4× CPU) by default, or desktop wired. Returns Core Web Vitals (LCP, FCP, CLS, TTFB, INP), Speed Index, Total Blocking Time, Time To Interactive, resource waterfall with render-blocking detection, diagnostics (DOM nodes, main-thread ms, total byte weight), Lighthouse-style performance score (0-100), and Good/Needs-Improvement/Poor ratings per PSI thresholds. Use after cloud_browser_open. Inputs: preset ('mobile'|'desktop'), timeout_ms (max 30000).

PNG of the active cloud-browser session. Optional `selector` is a CSS selector (e.g. `img[alt='Scrapfly Logo']`, `#header`, `.logo img`) — NOT a uid from `take_snapshot`. Without `selector`, captures the full viewport (or full page if `full_page: true`). For element-level shots where you only have a uid, prefer `take_screenshot` after `scroll`-ing the element into view; `take_screenshot` is the newer flat-API equivalent and is preferred in general.

List active cloud-browser sessions for this user with their URLs, registered WebMCP tools, and expiry. Useful when you lost track of what's open, or to decide between reusing an existing session and opening a fresh one.

Create an empty credential vault. The response carries the vault key once. Scrapfly stores no copy, so it cannot be retrieved again and losing it makes every item in the vault unreadable: show it to the user and have them save it before adding items. Two-step confirmation.

Delete a vault and every item it holds. This cannot be undone, and any Cloud Browser session that names the vault stops resolving credentials. Prefer cloud_browser_vault_item_delete when only one credential is unwanted. Two-step confirmation.

Fetch one vault: name, description, item count and, for a linked vault, the 1Password selection rules plus last sync time, sync status, sync error and counts. No secret material is returned. Use cloud_browser_vault_list when the id is unknown, cloud_browser_vault_item_list for the items themselves.

Add one credential to a vault. The vault key is required because the secret is sealed under it, and the server verifies the key before writing, so a wrong key fails here instead of leaving a row nothing can open. type is password, passkey, cookie, totp or blob, and secret must carry that type's fields. Two-step confirmation.

Delete one item from a vault. This cannot be undone and the credential is gone from every later Cloud Browser session. Items owned by a linked service are refused with a conflict; unlink the service first or drop the item upstream. Two-step confirmation.

List a vault's items: id, type, label, origin, username, provenance and timestamps. Secrets stay encrypted under the customer-held key, which Scrapfly does not have, and the ciphertext is dropped from this result, so no plaintext is ever returned. Rows whose source is not manual belong to the linked service and refuse edits.

Patch one vault item. Fields you send overwrite the row. Sending secret replaces the stored secret with no way back and requires the vault key; a label, origin, username or metadata patch does not. Items owned by a linked service are refused with a conflict. Two-step confirmation.

List the Cloud Browser credential vaults this API key can see in its project and environment, with item counts, vault_type, link state and last sync status. No secret material is returned. Start here to resolve a vault id for every other vault tool.

Rotate the vault key: send the current key, get a fresh one back once. The previous key is invalidated immediately, so every stored config and script still holding it stops opening the vault. Scrapfly keeps no copy of either key. Two-step confirmation.

Link a vault to 1Password so its items mirror an upstream vault. The vault key is required and verified first: the service-account token is sealed under it, and a well-formed wrong key would link the vault and leave a token every later sync fails to open. Run cloud_browser_vault_service_test first to pick the upstream vault. Two-step confirmation.

Sync a linked vault from 1Password now, bypassing the freshness window and the one hour back-off a failed run leaves behind. Needs the vault key to open the sealed token. Returns imported, updated, deleted, skipped, unmirrored, status and warnings. The server budget is 25 seconds.

Probe a 1Password service-account token and list the upstream vaults it can reach, changing nothing. The vault key is required. Pass token to check one that is not stored yet, or omit it to probe the token already sealed in the vault. Every call spends the provider's rate-limit budget. The server budget is 10 seconds.

Unlink a vault from 1Password. keep_items defaults to true and leaves the mirrored rows behind as manual items; keep_items=false deletes every mirrored row and that cannot be undone. The sealed service-account token is deleted either way. Two-step confirmation.

Change a linked vault's 1Password selection rules, rotate its service-account token, or both. linked_service_data replaces the stored document wholesale, so send every field you want kept. The vault key is required only when a token is sent, and token_item_id in the body is ignored. Two-step confirmation.

Rename a vault or change its description. Items, the vault key and any linked service stay as they are. A rename breaks session configs that select the vault by its old name. Use cloud_browser_vault_service_update for 1Password selection rules. Two-step confirmation.

Drag one element onto another (both by `uid`). Use for HTML5 drag-and-drop interfaces — reordering lists, uploading via drop zones, Trello-style boards. Rare outside those cases.

Return all <option> entries (value, label, selected) of a native HTML <select> element by uid. Use before select_option to discover available choices when the snapshot's `options="a|b|c"` enrichment is truncated or missing.

Evaluate a JS expression in the page and return its value. Use for *reading*: extract a computed value, read localStorage, inspect window state, pull structured data the snapshot doesn't expose. Do NOT use for interaction — `click`/`fill`/`type_text` are the supported paths and survive anti-bot checks. Script runs as `(() => <your expr>)()` in the main world.

Set the value of an input/textarea in one shot (faster than `type_text`). Prefer this for forms, search boxes, addresses. Requires `uid` from a recent `take_snapshot`. Use `type_text` instead only when the page has a live autocomplete that needs per-keystroke events.

Return up to 20 elements matching a CSS selector with their tag, text excerpt (80 chars), and key attributes. Use when take_snapshot doesn't expose what you need — typically for non-interactive content selection (`<article>`, `.product-card`, `[data-id]`). Returns an empty list rather than an error when nothing matches.

Return the browser's current URL and page title. Cheap; use it to confirm a navigation landed where you expected, or to capture the final URL after redirects before reporting back to the user.

Navigate one step back in the browser's history (equivalent to clicking the browser's back arrow). Returns an error if there's nothing to go back to. After this call, take_snapshot to see the previous page's elements — DOM uids from prior snapshots are stale.

Move the mouse over an element (by `uid` from `take_snapshot`). Use when a page reveals menus, tooltips, or controls only on hover — otherwise `click` is what you want.

Reveal the Scrapfly API key this MCP server is authenticated with, so the user can paste it into their own code (SDK snippet, curl, CI secret). The key is a live credential: show it only when the user explicitly asked for their key, and never echo it back in later turns or embed it in generated files that get committed. The other tools already authenticate themselves — you never need this to call `web_scrape`, `screenshot` or `cloud_browser_open`. For plan / credit / quota questions use `info_account` instead.

List the WebMCP tools the current page has registered via `navigator.modelContext.registerTool()`. Returns name, description, and input schema for each. When a page exposes these, they are an author-provided programmatic API — prefer calling one via `call_webmcp_tool` over DOM scraping or UI clicks. The `cloud_browser_open` and `cloud_browser_navigate` responses already surface this list, so you rarely need to call this directly.

Send a single key to the focused element. Accepts names like Enter, Tab, Escape, ArrowDown, Backspace. Typical use: submit a form (Enter), navigate a listbox (ArrowDown), close a modal (Escape).

Return a concise cheat-sheet of Scrapfly's scraping options (proxy pool, render_js, country, extraction) and which of `web_scrape` / `web_get_page` accepts each. Optional — useful on an unfamiliar target so the chosen options are right the first time.

One-shot PNG screenshot of a URL. Stateless — loads the page, renders, returns the image. Inputs: `url` (required, must be http:// or https://), `capture` (optional — either 'fullpage' or a CSS selector such as `img[alt='Logo']`). There is NO `selector` parameter — use `capture` for element-cropped shots. When to use this vs `cloud_browser_open` + `cloud_browser_screenshot`: • Use `screenshot` only for truly stateless captures ("give me a screenshot of <url>") where the user does not need to see a live browser panel and will not follow up with more actions on the same page. • Prefer `clou…

Scroll either (a) a specific element into view by `uid`, or (b) the page by a pixel delta, or (c) to bottom via selector type "bottom". Use (a) before clicking an off-screen element; use (c) to trigger infinite-scroll pagination; retake a snapshot afterwards since new content typically appears.

Scroll the active page until the first element whose textContent contains the given substring is in the viewport. Case-insensitive substring match. No-op if the text is already visible. Cheap to call before any click on content that may be below the fold (long articles, lazy-loaded lists, paginated tables). Returns the matched element's tag and a 80-char text excerpt, or an error if not found.

Pick an option from a native HTML `<select>` by the dropdown's `uid` and the option's `value` attribute (not its visible label). For custom dropdowns built out of divs, use `click` instead.

Capture a PNG of the current cloud-browser page. Use when the user asks for a visual, or when the page's information (charts, diagrams, styled layout) isn't well-represented by the accessibility tree. For structural/text understanding, `take_snapshot` is cheaper and more actionable.

Return the current page's accessibility tree as structured text with element uids. This is your primary way to see and act on the page — read it to find links, buttons, inputs, headings, then use their uids with `click`, `fill`, `hover`, etc. Cheap — call it freely whenever you're unsure what's on the page or after an action that likely changed the DOM. Do NOT guess uids.

Type text character-by-character into the currently focused input (use after clicking/focusing). Slower than `fill` but fires per-keystroke events — needed for live autocompletes, search-as-you-type, or inputs that reject setValue-style writes.

Sleep for N seconds before the next action. Use sparingly — most pages can be interacted with as soon as the snapshot returns. Useful for waiting on animations to settle, on lazy-loaded carousels, or on deliberate rate-limiting between repeated form submissions. Capped at 10s server-side; longer sleeps will be clamped.

One-shot fetch of a URL with sane defaults. Stateless. Right choice for simple "get me the page / the JSON / the file at X" asks — including plain file downloads where the URL already points at the asset. Falls back to `web_scrape` when you need to tune headers/JS-rendering/proxy; to `cloud_browser_open` when the task needs interaction with the page. Proxy pools: `basic` (datacenter proxies, Unblocker off), `unblocker` (residential proxies and the Unblocker), `unblocker_ultra` (the same, and the only pool a target or an anti-bot protection with a price of its own accepts) and `auto` (the API p…

One-shot fetch of a URL with full control (headers, JS rendering, country, proxy pool). Stateless — returns the response body and metadata, no persistent session. This is the right tool whenever the task is "get the content/bytes at this URL": downloading a file, fetching an HTML page, calling a JSON endpoint, grabbing a sitemap. Only switch to `cloud_browser_open` when the task requires multi-step interaction with a page (clicking, form filling, navigating between pages, logging in). Use `scraping_instruction_enhanced` first if you're uncertain which options to set. Prefer `web_get_page` for …