Launch Camoufox stealth browser and navigate to URL. Browser persists between calls. By default cookies/localStorage persist in ~/.camoufox-mcp/profile. Set fresh_profile=true to start with a clean temp profile (auto-cleaned on browser_close) — useful when switching between accounts on the same domain.

Close the browser. Cookies are preserved in the persistent profile (~/.camoufox-mcp/profile). If the launch used fresh_profile=true, the temp profile is removed.

Delete the persistent profile (~/.camoufox-mcp/profile) entirely. Use to start fresh — cookies, localStorage, history all wiped. Browser must be closed first (call browser_close before this).

Navigate to a URL.

Navigate back in history.

Navigate forward in history.

Reload the current page.

Get visible interactive elements with ref IDs. Use refs with click/fill. Always call after navigation. On large pages (Outlook, dashboards) the response can be truncated — narrow with roles=["button","textbox"] or paginate with offset/limit. Refs stay stable regardless of filters (every visible element is still numbered).

Screenshot the page, or a single element with ref/selector (great for documenting one modal). Returns the IMAGE inline — no second Read call — plus the saved path. Set return_image=false for path only.

Click element by ref ID from browser_snapshot. Auto JS-fallback for overlays.

Click element by visible text. If the text matches several elements it FAILS with a numbered candidate list instead of silently clicking the first one — narrow with within ("@dialog", a CSS selector, or "ref:e5") or pick one with index.

Click element by ARIA role and name. Same ambiguity guard as click_text: several matches → candidate list, not a guess.

Hover over element by ref ID.

Fill input/textarea by ref ID. Always replaces existing content (email/number inputs are cleared explicitly first — Firefox's select-all is a no-op on those, which would otherwise append).

Select option from dropdown.

Check checkbox or radio button.

Uncheck a checkbox.

Type text char by char via keyboard.

Press key or combo (Enter, Escape, Control+a, etc.).

Wait for element/text to appear or disappear.

Wait for page load to complete.

Race multiple wait conditions — returns the first that matches, so the agent can branch immediately without sequential probes. Each condition is {kind: 'selector'|'text'|'url_contains'|'title_contains', value: string}. Returns the index + kind + value of the winning condition (or 'timeout' if none matched). Ideal for post-login flows where the next page could be any of several (e.g. 'Stay signed in?', 'Skip for now', or the inbox directly).

Execute JavaScript in page context.

Get current URL and title.

Get visible text from page or element.

Get HTML content from page or element.

List all open tabs.

Open new tab.

Switch to a tab by index, or by url_contains (first tab whose URL contains the substring).

Close a tab by index (-1 = active), or by url_contains.

List cookies.

Set a cookie. IMPORTANT: with expires_days=0 this creates a SESSION cookie, which Firefox keeps in memory only — it is gone after browser_close even though the profile itself persists. Pass expires_days (e.g. 30) to write a login session that survives a relaunch.

Delete cookies. Both empty = clear all.

Set handler for the next alert/confirm/prompt on ANY open tab (first dialog wins, handler then clears).

Upload file to file input.

Generate or edit an image on chatgpt.com end-to-end and save it to disk in ONE call. Opens a fresh chat, optionally uploads reference images (e.g. a brand logo), submits the prompt, waits for the generated image to finish, then writes the result PNG to output_path. Requires an authenticated chatgpt.com session (import cookies first via cookie_import). Returns the saved path and pixel dimensions. Note: chatgpt image generation is slow (~60-120s) — set timeout_ms accordingly.

Generate MANY images on chatgpt.com IN PARALLEL (one tab per job, fire-all-then-collect) and save each to disk. Submits every job first WITHOUT waiting, then waits for all generations concurrently — far faster than sequential. For a CONSISTENT feed set, pass shared_image_paths (e.g. [logo] and/or a style-reference image like a previously-generated hero) uploaded to EVERY tab, plus style_suffix (a shared style spec) appended to every prompt. Requires an authenticated chatgpt.com session (import cookies first). Returns per-job results (saved path / ok / bytes / error).

Scroll the page.

Start capturing console messages from all tabs.

Get captured console messages.

Start capturing network requests. With capture_bodies=true also records request/response headers + text bodies (json/text/xml/form only, capped at body_limit bytes) so you can inspect API payloads via network_get_detail — no need to pivot to evaluate()+fetch().

List captured network requests in capture order, keeping the most recent limit rows. Each row shows an #id usable with network_get_detail.

Full request + response detail (headers and text body) for one captured request. Requires network_start(capture_bodies=true) BEFORE the request fired. Identify the request by id (from network_get) or by url substring.

Save page as PDF. NOTE: Playwright can only generate PDFs in headless Chromium — Camoufox is Firefox, so this fails by design here. Use screenshot(full_page=true) instead. Kept for API compatibility.

Execute multiple actions in one call. Each action: {type, ref?, value?, text?, key?, url?}.

Fill multiple form fields and optionally submit.

Composite login for classic email→password forms (Google, Microsoft, generic SSO). Auto-detects the email field, clicks Next/Continue on multi-step forms, fills the password, submits, and optionally enters a TOTP 2FA code. Collapses the usual 5–8 fill/click/snapshot calls into one. Heuristic — if a form is unusual, fall back to individual fill/click tools. Returns the step log + a fresh snapshot.

Navigate to URL then return snapshot — combined in one call.

Block requests before they leave the browser. Blocking image/media/font/stylesheet typically removes most of a page's bytes — the single biggest speed-up for scraping — and block_urls kills trackers and ad frames. Routed on the context, so tabs opened later are covered too. Re-calling replaces the previous rules; intercept_stop removes them. 'document' cannot be blocked: it would abort the navigation itself.

Remove interception rules and report what they blocked.

Show what interception blocked and allowed.

Rebuild a captured request as a runnable curl command, so you can replay or share an API call without re-deriving its headers. Needs network_start(capture_bodies=true) — headers are not recorded otherwise.

Get detailed info about an element (tag, attributes, bounding box, styles).

Get a specific attribute value from an element.

Query elements by CSS selector, return text/attributes of all matches.

Get all links on the page with URL and text.

Get all localStorage data or a specific key.

Set a localStorage item.

Clear all localStorage.

Get all sessionStorage data or a specific key.

Set a sessionStorage item.

Click at exact x,y coordinates. steps>0 adds interpolated pre-movement (human-like).

Move mouse to x,y. steps>0 interpolates path (human-like).

Auto-solve Cloudflare Interactive Turnstile checkbox. Locates the widget via in-page selectors AND the Playwright frame API (handles closed shadow roots that document.querySelector misses), polls for render, skips if already solved, then does a humanized real-mouse click with retries + small nudge, verifying the cf-turnstile-response token after each attempt. Managed Challenge full-page interstitials still need mcp-stealth-chrome.

Drag from one element to another.

List all frames/iframes in the page.

Execute JavaScript inside a specific frame/iframe.

Wait for URL to match a pattern.

Wait for a network response matching a URL pattern.

Get current viewport dimensions.

Set the viewport width and height. This is the exact control over what the page renders and what a screenshot captures. It does NOT resize the OS window: Camoufox reports a frozen outerWidth/outerHeight, so asking for a viewport larger than the launch window makes the content bigger than its own window — impossible geometry that a detector can read. The reply says so when that happens.

Get accessibility tree snapshot — compact view of page structure for LLM understanding.

Health check — verify server, browser status, active tabs.

Get uncaught JavaScript errors + unhandled promise rejections from the current page. Captured by a hook installed at browser_launch, so the buffer resets on every navigation (read it before navigating away). Max 100 entries per page load.

Inject a script that runs before every page load.

Export captured network traffic as a HAR 1.2 file (openable in DevTools/other HAR viewers). Requires network_start first; headers and bodies are only included when network_start(capture_bodies=true) was used.

Report the fingerprint a site actually sees from this browser, and flag internal contradictions — the mismatches that get an automated browser detected are far more revealing than any single value. Read-only: it inspects, it does not change anything.

Auto-detect repeated content patterns (cards, listings, rows) and suggest CSS selectors. Run this BEFORE extract_structured to find the right selectors.

Extract structured data from repeated elements (cards, rows, listings). Auto-deduplicates, filters empty items, extracts direct text only. Use detect_content_pattern first to find correct selectors.

Extract data from an HTML table as JSON array.

Smart page scraper — auto-detect and extract main content, links, metadata. Strips nav/footer noise.

Wait for selector/text then return snapshot. Combines wait_for + browser_snapshot in one call.

Navigate back + return snapshot.

Reload page + return snapshot.

Click element by ref + wait + return snapshot. Perfect for buttons that trigger navigation/dialog.

Find elements by visible text — returns EVERY match (total + a ref and ancestor path per candidate), so you can tell whether the one you want is really the one you'd click. Skip browser_snapshot when you know the text.

Find input element by its label text (). Returns ref + how many matched.

Find input by placeholder text. Returns ref + how many matched.

Export all cookies as JSON string. Use with cookie_import to transfer session.

Import cookies from JSON (from cookie_export). Restores session state.

Page statistics: element count, size, load metrics. Use to decide extraction strategy.

Save cookies + localStorage to a JSON file. Reload via storage_state_load on a fresh browser to skip login/CF entirely.

Load cookies + localStorage from a JSON file (created by storage_state_save). Bypass CF/login if session is fresh.

Save current session as named auth state (e.g. logged-in user). Convenience wrapper: storage_state_save to ~/.camoufox-mcp/sessions/.json

Export all cookies to a JSON file (Playwright format).

Import cookies from a JSON file (Playwright format).

Click element with humanized mouse approach (3-step Bezier-like curve before click). Use for anti-bot pages.

Type text with Gaussian-distributed delays between keystrokes (mean ~80ms, sigma ~30ms). Mimics human typing rhythm.

Random mouse movements over a duration — builds up mouse history before action (CF/DataDome behavior analysis).

Start recording mouse positions in the page (replay with mouse_replay). Re-calling replaces any previous recorder instead of leaking its listener.

Replay last recorded mouse path with original timing.

Visit innocuous public sites (Google, Wikipedia) to build browsing history before targeting protected site. Helps with CF/DataDome IP scoring.

Heuristic detection of anti-bot vendor on current page (Cloudflare, DataDome, Akamai, PerimeterX, Imperva).

Assert element exists and is visible. Returns success/fail (no throw).

Assert text is present anywhere on page (case-sensitive substring).

Assert current URL matches pattern (substring or regex).

Click element then wait for navigation or selector. Atomic — fewer roundtrips than separate click + wait_for.

Wait until there are no in-flight requests for idle_ms continuously. Requests are counted from the moment the page was opened, so one that was ALREADY in flight when you call this is not mistaken for idle.

Compact LLM-friendly page summary (title, heading, key buttons, forms). Cheaper than browser_snapshot for agent context. Also returns intent — a classified hint of what kind of page this is (login_email, login_password, otp_input, captcha, stay_signed_in, protect_account, error_page, consent, two_factor, account_disabled, content, unknown) — so the agent can branch with one read.

HTTP request WITHOUT a browser, using a real Firefox TLS/HTTP2 fingerprint (impit). By default it reuses the live browser's cookies for that URL, so you can log in with the browser and then hit the site's API cheaply. Far faster and lighter than navigating — use it for APIs, JSON, and any page that doesn't need JS.

Show which browser cookies would be sent with an HTTP request to this URL. Use it to confirm session sharing before relying on http_request.

Search the web through a search API YOU control — a self-hosted SearXNG, or Brave/Tavily/Exa with a key — and get back a normalised title/url/snippet list. This never scrapes a SERP: that shipped in 0.9.0 and was removed in 0.9.2 because engines answer some queries with confidently wrong results. A real API contract does not have that failure mode. Set MCP_SEARCH_ENDPOINT (and MCP_SEARCH_API_KEY when the provider needs one) to avoid passing them every call.

Fetch a URL and return clean, LLM-ready markdown (headings, links, lists preserved; nav/footer/scripts stripped). Default path is browserless (impit) — fast and cheap. Set use_browser=true for JS-rendered pages (needs browser_launch).

Dual-mode fetch: tries the browserless HTTP path first and escalates to the stealth browser ONLY when the response looks anti-bot blocked. This is the efficiency core — high-volume reading stays cheap, the browser fires only when it's actually needed.

Grep the CURRENT page's visible text and return matches with surrounding context. Costs nothing compared to a snapshot or a screenshot — use it first to find where a term actually appears.

Wait until the page actually CHANGES and report what changed (url / title / DOM size / text). This is the honest version of a fixed sleep after a click: it returns as soon as something happened, or tells you nothing did.

Hit-test an element WITHOUT clicking: would a real click actually land on it? Answers "why did my click do nothing?" before you spend the click. Reports the element that would intercept the click when something covers it.

Scroll a specific element into view (the page-level scroll tool only moves by pixels).

Click at a percentage position inside an element instead of its centre — for wide labels whose real checkbox sits at the left edge, sliders, or split buttons.

Click a corner of an element — close/X buttons, delete icons and dismiss controls usually live there, not in the centre.

Fill a field with a REAL paste. Puts the text on the clipboard and presses Ctrl/Cmd+V so the page receives a trusted paste event with actual clipboardData — the only thing that works for frameworks that listen to paste alone (Svelte 5 / SolidJS runes, some Qwik forms). Falls back to a synthetic event and then the native value setter.

Analyse a form in one call: per field the label, type, current value, required/pattern/length constraints, validation state, and the JS framework it is bound to. Tells you what to fill and why a submit is being rejected without guessing from a snapshot.

Fill form fields by their LABEL text (fuzzy, case-insensitive) instead of refs — no snapshot needed. Values go through the same clearing logic as fill, so email/number fields replace rather than append.

Install a PERSISTENT dialog handler that stays armed across every dialog and every tab (dialog_handle is one-shot). Reads its action at fire time, so you can change it without re-arming. Set enabled=false to remove it.

Clear all sessionStorage for the current origin (parity with localstorage_clear).

Block until the page ISSUES a request matching a URL substring (wait_for_response waits for the reply). Use it to confirm an action actually fired its API call.

Capture cookies + localStorage + sessionStorage + URL into a named slot, so storage_diff can tell you exactly what an action changed.

Compare current storage against an earlier storage_snapshot — shows exactly which cookies/localStorage/sessionStorage keys were added, removed or changed. The fastest way to find which key holds a session token.

List IndexedDB databases for the current origin. Many SPAs keep auth state and drafts here, invisible to cookie/localStorage tools.

Delete an IndexedDB database by name for the current origin (clears SPA state that survives a cookie wipe).

Navigation + paint + resource timing for the current page: TTFB, DOMContentLoaded, load, FCP, LCP, and the 5 slowest resources. Note: Firefox does not implement layout-shift, so CLS is unavailable here.

Escape hatch when the browser is wedged and browser_close can't complete: force-drops the connection and resets server state so browser_launch works again. Also reports a profile lock held by another Camoufox process, which is the usual cause of 'A copy of Camoufox is already open'.

Run a list of tool calls in sequence — any tool this server exposes, by name — and return a per-step log. Resumable: a failed run tells you the index, and start_at skips the steps that already succeeded. Each step is {"tool":"navigate","args":{"url":"…"},"label":"optional"}.