Svipall

Close a session opened with browser_open and release its browser. Call it when the multi-step work is done; sessions left open keep a browser running.

Navigate and act inside a session from browser_open: the same actions as web_act, `ref` from web_snapshot accepted. Omit `url` to keep acting on the current page. Returns per-action results and the page content, filtered by `query` when given.

Open a persistent stealth browser session and return a `session_id` for browser_do. Use for multi-step work where cookies and page state must survive between calls: log in, then browse; add to cart, then check out. For one page and a few actions web_act is simpler. `profile` reuses cookies saved by web_login. Close it with browser_close.

Manage the browser behind the browser, stealth, real and warm tiers. `status` (default) says which binary would run and why; `install` downloads Chrome for Testing (about 190 MB) when the machine has none; `update` replaces it with current stable; `remove` deletes it. Use when a fetch or web_status reports no usable browser. Nothing is downloaded unless asked.

Check a captcha task by its `taskId`, as returned by solve_turnstile, solve_recaptcha_v2, solve_hcaptcha or solve_image_captcha. Returns `status` solved, processing or failed, with the token or text once solved.

Report whether a captcha answer worked (`good=true`) or was rejected (`good=false`), by `taskId`. Call it after submitting a token from solve_turnstile, solve_recaptcha_v2 or solve_hcaptcha: the outcome orders the strategies tried next time on that route, so an unreported rejection is repeated.

Solve the captcha on a blocked page in place and return the page behind it. The right choice whenever the goal is the content: solve_turnstile, solve_recaptcha_v2 and solve_hcaptcha return a bare token bound to the session and address that produced it, which rarely works elsewhere. Use after web_fetch returns `blocked_reason` with a captcha widget. Non-interactive widgets clear on their own; one that needs a person opens a visible window or the dashboard (URL in web_status).

Solve an hCaptcha challenge from its `sitekey` and `pageUrl` and return the token. Use only when you will submit the token yourself from the same session and address; to read the page behind the challenge use solve_and_continue. Returns the token, or a `taskId` to follow with captcha_status while a person solves it.

Read the characters in an image captcha given as base64 or a URL and return them as text. Use when a form shows a picture of distorted characters you will type yourself; for a challenge widget on a blocked page use solve_and_continue. Returns `text`, or a `taskId` to follow with captcha_status.

Solve a reCAPTCHA v2 challenge from its `sitekey` and `pageUrl` and return the gRecaptchaResponse token. Use only when you will submit the token yourself from the same session and address; to read the page behind the challenge use solve_and_continue. Returns the token, or a `taskId` to follow with captcha_status while a person solves it.

Solve a Turnstile challenge from its `sitekey` and `pageUrl` and return the token. Use only when you will submit the token yourself from the same session and address, such as a form posted with web_fetch method=POST; to read the page behind the challenge use solve_and_continue. Returns the token, or a `taskId` to follow with captcha_status while a person solves it.

Open a URL in a browser, run a list of actions and return the resulting page. One shot with no session: for several steps on one login or cart use browser_open + browser_do. Take a web_snapshot first and name elements by `ref`. Actions: click, type, fill, press, hover, select, scroll (`until:'stable'` loads everything), wait, eval, goto, verify, console, screenshot, hold; each is an object with `do` and the fields it needs. Returns per-action results and the final page as markdown.

Record the JSON and XHR responses a page fetches while it loads and return them: the site's own API, smaller, typed and more stable than the HTML built from it. Use to find the real endpoint behind a listing or pagination; an endpoint that took page=1 takes page=2, which beats following links. Call once without `pattern` to see what the page asked for, then with `pattern` (URL substring) and `bodies=true` for the payloads. Returns `endpoints` and `responses` with url, status, mime, and body when asked.

Crawl one site from a start URL and return every page as markdown, deduplicated, robots.txt obeyed. Use when the pages are not known in advance; when they are, web_fetch_many is cheaper, and web_map lists a site's URLs for a few hundred tokens before deciding to crawl. `max_pages` (20), `max_depth` (2), `include` (URL substring), `query` (rank by relevance, stop when saturated), `strategy=dfs` for a manual or a paginated listing, `schema` or `tables` for rows from every page. For many rows pass `out_file` (.csv, .json, .jsonl): a path comes back instead of the pages. Returns the pages and a `crawl_id`; pass it back as `crawl_id` to resume an interrupted crawl. Links to a page's own site are paths, to be joined to that page's `url`.

Compare a page with the copy svipall cached last time and return what changed: `changed`, `similarity`, and the `added` and `removed` markdown blocks. Use for a one-off question of whether a page changed since it was last read; to keep checking on a schedule use web_watch. Cheap: the comparison is a stored fingerprint, not a second full copy.

Fetch one URL and return its main content as markdown (PDF and office documents too), or as rows with `schema` or `tables`. The default way to read a page: `mode=auto` climbs http -> browser -> stealth -> real -> warm, remembers the working tier per domain, and is never set by hand. Cut tokens with `query` (keep only relevant blocks), `css_selector`, `max_tokens` + `cursor` (page through), or `out_file` (write to disk, return a path). To click use web_snapshot; for the site's JSON API use web_capture; for several known URLs use web_fetch_many. Returns `content`, `title`, `tier_used` and `quality`; links to the page's own site are paths, to be joined to `url`. A wall returns `blocked_reason` and a `note` saying what to do: act on it, never retry blindly.

Fetch several URLs in parallel with the same escalation, `query` filter, `schema` and `tables` as web_fetch, results in input order. Use when the URLs are already known, from web_search, web_map or a listing; to discover them use web_crawl. Returns one web_fetch result per URL plus `corroboration`: how many distinct documents the set really is, duplicates marked `same_text_as`.

Report what this installation has done per domain: which tier answered, which wall appeared, how long it took. `view=summary` shows domains that are half blocked or slow, the sign of a learned tier gone wrong (reset it with web_status forget_tier); `view=recent` lists the last events. web_status shows the current state; this is the history.

Open a visible browser window so a person can log in or pass a challenge by hand, then save the cookies to a profile. Use when a fetch returns `blocked_reason` naming a login wall or a challenge no automatic tier clears. Without `profile` the domain's auto profile is used and later fetches pick it up on their own; name a `profile` to reuse it explicitly. Move it to another machine with web_profile.

List a site's URLs without fetching its pages: robots.txt, sitemaps (nested indexes and .gz), RSS/Atom feeds and homepage links. Use before web_crawl to decide what is worth fetching, or to find the page for a topic: a few hundred tokens instead of the thousands a crawl costs. Returns `urls` with `sources_used`, `sitemaps` and `feeds`; read the ones that matter with web_fetch_many.

Remember a value across sessions: `set` a key, `get` it back, `list` by prefix, `delete` it. Use for state needed in a later session, such as the last id seen, a learned URL pattern or a checkpoint. Keys are path-like (`shop/last_id`) so a prefix groups them.

Move a logged-in browser profile between machines: `export` writes an encrypted archive, `import` restores it, `list` shows the profiles web_login saved. Use so a challenge a person passed once with web_login is not passed again elsewhere. `password` is required; there is no unencrypted form.

Send one domain (subdomains inherit) through a proxy from now on, or through a pool with `proxies` and `countries`; `remove` drops the route, no arguments lists routes, `check=true` tests the exits for liveness, latency and DNS leak. Use when a fingerprinting wall never yields at any tier, or a site is locked to a country. Give `country` so the browser's timezone and language match the exit.web_status shows each exit's health per domain.

Save a PNG of a page rendered in a real browser, anti-bot handled like web_fetch, and return its path, by default with the image inline. Use when the question is visual: layout, a chart, an image, how a page looks to a person. To read or act on a page use web_snapshot instead: cheaper, and it gives refs, whereas a screenshot cannot be clicked. `full_page` captures the whole scroll height, `mobile` renders it as a phone.

Search the web without an API key by reading public search engines' own result pages; the first engine with results answers, `engine=all` merges them. Use to find URLs for a topic, then read them with web_fetch or web_fetch_many. To search inside one site use web_site_search. Returns title, url and snippet per result, not the pages.

Search one site through its own search box and learn the URL pattern the form produces. Use for shops, job boards and docs whose content only appears when asked for: a crawl reaches only what is linked, and web_search covers the whole web, not one site. Returns `results_url`, the pattern (`/search?q=...`) that makes every later query a plain web_fetch with no browser, plus the first results while `fetch` is true.

Read a page as its interactive structure: every button, link and field with its role, accessible name and a short `ref` such as e12. Use instead of web_fetch when the next step is to click or type, and instead of web_screenshot when a page has to be understood: deterministic, no image, a fraction of the tokens. `find` keeps only matching nodes, `max_depth` goes shallower. Returns the nodes; pass a `ref` to web_act or browser_do so no CSS selector has to be guessed.

Show the current state: learned tiers, cooldowns, address budgets, proxy routes, profiles, open browser sessions, resumable crawls, solver stats and the dashboard URL. Use when something is blocked or slow to see why, and to reset it: `clear_cooldown`, `forget_tier`, `clear_budget` and `clear_cache` take a domain. Without arguments nothing changes. The history per domain is web_log.

Read a video: captions and chapters as one `[m:ss]` timeline, from a watch page, an embedded player, <video> tracks or the stream manifest. Use instead of web_fetch on a video page, which returns only the description. Returns `content`, `captions` (manual, auto or asr), `chapters`, `notes`; an encrypted stream is reported as `drm`, never read.

Watch a page, or one `css_selector` region of it, and report when it changes. `add` starts a watch (`interval_secs`, default 3600), `list` shows what changed and when, `check` looks now, `remove` stops. A check that finds nothing costs one conditional request. Watches survive restarts but run only while the server is up. For a single comparison with no watch use web_diff.