Browser-backed web access, automation and structured data extraction for AI agents.
Scored across 43 tools
Descriptions are unusually thorough and cross-reference each other, which helps a lot, but the surface is split into two near-parallel lineages (standalone `importio_goto`/`importio_render`/`importio_wait`/`importio_viewport`/`importio_scroll_to` versus their `importio_action_*` pipeline twins) and there are five wait variants (wait, wait_for_selector, wait_loading, wait_for_function, wait_region_mutation) plus `importio_extract_data` vs `importio_action_extract_data` vs `importio_suggest_data`. An agent must reason carefully about pipeline context before picking a tool, which is inherent ambiguity even if documented.
All tools share the `importio_` prefix and use snake_case, with a clear `importio_action_<verb>` convention for pipeline steps versus `importio_<verb>_<noun>` for standalone helpers. Minor deviations exist (`importio_stop`, `importio_refresh`, `importio_query_queue`, `importio_call_method`) where no noun or verb_noun shape is used, but nothing chaotic.
43 tools is well beyond the comfortable 3-15 range and the bulk comes from duplicating an already-large standalone surface as pipeline actions. A browser-automation engine legitimately needs breadth, but the two-layer design inflates the count and increases selection cost.
Coverage is strong: navigation, rendering, fetch, HTML/text/link/card inspection, extraction, search, the full action vocabulary (click, input, select, keyboard, mouse, scroll, loop, pagination, flow control, captcha, screenshot), waits, viewport, and session teardown. Gaps are modest — no cookie/storage/header management, no multi-tab/target handling, and no download or PDF/asset-dump tool beyond single `request_asset`.
Trigger captcha handling on the current page when an importio_play_action pipeline encounters a challenge; fields carries the upstream CaptchaAction configuration. It is for working through a legitimate challenge, not for bypassing a site's access controls.
Inputs: fields (required), input, optional.
Click a confirmed button, link, or checkbox inside an importio_play_action pipeline. Use fields.selector for a confirmed button, link, or checkbox; the server builds Chromium's MouseEvent target. Verify the page changed after the click. For form submission, click the submit button or use importio_action_keyboard for Enter. Hover, drag, and other pointer work a selector click cannot express belongs in importio_action_mouse.
Inputs: fields (required), input, optional.
Run a JavaScript snippet through the upstream CodeAction inside an importio_play_action pipeline. Do not assume this runs in page DOM context; browser globals such as document or window may be unavailable. Do not use this for DOM scraping on unknown data pages. For DOM inspection or interaction, use importio_web_fetch, importio_get_html with options.replaceAssets=false, and selector-based actions.
Inputs: fields (required), input, optional.
Run structured extraction inside an importio_play_action pipeline; fields carries the extraction runtimeConfig. Use it for structured extraction when you already know the extraction configuration. Do not use it for selector discovery, unknown data pages, or login/forms. Empty results usually mean the config/selectors did not match the rendered page. For a one-off extraction outside a pipeline use importio_extract_data.
Inputs: fields (required), input, optional.
Branch or halt an importio_play_action pipeline through the upstream FlowControlAction; fields carries its configuration. Use it only when you know the upstream flow-control shape; simple repetition belongs in importio_action_loop.
Inputs: fields (required), input, optional.
Run a JavaScript function inside an importio_play_action pipeline; fields carries the upstream FunctionAction configuration. Advanced action: use it only when you know the upstream function action shape. Do not use it as the first fallback for form interaction failures; if the engine reports FunctionActionError or cannot read toString, stop and report the upstream action incompatibility.
Inputs: fields (required), input, optional.
Navigate the browser to a URL as one step inside an importio_play_action pipeline; fields carries the EngineRequestOptions, typically url and wait. For standalone navigation use importio_goto, and confirm readiness with importio_action_wait_for_selector before reading content.
Inputs: fields (required), input, optional.
Set a form control's value inside an importio_play_action pipeline; fields carries selector and value. Use it to fill form controls after waiting for a selector. For login/forms, prefer wait_for_selector, input_change for each field, then click or keyboard submit. If this fails with synthetic event errors such as preventDefault or target being undefined, do not retry the same action repeatedly; try keyboard-based input if available, otherwise report that the site's event handlers are incompatible with the current browser action.
Inputs: fields (required), input, optional.
Press a single key inside an importio_play_action pipeline, typically Enter to submit after form fields are filled; fields carries the upstream KeyAction configuration. For full typing sequences use importio_action_keyboard, and for click-based submission use importio_action_click.
Inputs: fields (required), input, optional.
Type text or send key sequences through real keyboard events inside an importio_play_action pipeline, for sites whose handlers ignore synthetic value changes; fields carries the text or keys to send. For direct value setting use importio_action_input_change, and for a single key press use importio_action_key.
Inputs: fields (required), input, optional.
Repeat a nested action sequence within a single importio_play_action pipeline; fields carries the upstream LoopAction configuration defining what repeats and when to stop. Verify deduplication and stop conditions in the calling workflow, because a misconfigured loop can run indefinitely.
Inputs: fields (required), input, optional.
Send raw pointer events (move, down, up) for hover, drag, or canvas work where a selector click does not apply; fields carries the upstream MouseAction configuration. For standard activation of a button or link use importio_action_click, and for typing use importio_action_keyboard.
Inputs: fields (required), input, optional.
Advance a paginated listing to its next page inside an importio_play_action pipeline, then run extraction again on the new page; fields carries the upstream PaginationAction configuration. For repeating a nested sequence an arbitrary number of times use importio_action_loop.
Inputs: fields (required), input, optional.
Render the current page, or the EngineRequestOptions supplied in fields, as one step inside an importio_play_action pipeline. For a one-shot load-a-URL-and-read-content call use importio_web_fetch, and for a standalone re-render use importio_render.
Inputs: fields (required), input, optional.
Capture a screenshot of the current viewport for debugging or visual evidence inside an importio_play_action pipeline; fields carries the upstream ScreenCaptureAction configuration.
Inputs: fields (required), input, optional.
Scroll the page inside an importio_play_action pipeline to trigger lazy loading or reach below-the-fold content before extraction; fields carries the upstream ScrollAction configuration. The deprecated coordinate jump is importio_scroll_to, and to resize the viewport within the same pipeline use importio_action_viewport (standalone setup: importio_viewport).
Inputs: fields (required), input, optional.
Change the selected option of a element inside an importio_play_action pipeline; fields carries the upstream SelectChangeAction configuration with the target element and value. Selecting an option directly is more reliable than clicking through dropdown UI. For text inputs use importio_action_input_change.
Inputs: fields (required), input, optional.
Resize the browser viewport inside an importio_play_action pipeline; fields carries the width and height in CSS pixels. For standalone viewport setup use importio_viewport.
Inputs: fields (required), input, optional.
Pause briefly inside an importio_play_action pipeline; fields carries the upstream WaitAction configuration. For an element's readiness use importio_action_wait_for_selector, for load settling use importio_action_wait_loading, and for a standalone sleep use importio_wait.
Inputs: fields (required), input, optional.
Wait until a page-side JavaScript condition supplied in fields reports completion inside an importio_play_action pipeline; fields carries the upstream WaitForFunctionAction configuration. Use it only when fixed waits and element presence cannot express the readiness condition; for element presence use importio_action_wait_for_selector.
Inputs: fields (required), input, optional.
Wait until the element named in fields exists before continuing an importio_play_action pipeline. Use after navigation before interacting with dynamic pages; fields.selector should identify the element that must exist before continuing. Reach for it instead of generic waits when a concrete element signals that the page is ready.
Inputs: fields (required), input, optional.
Block until the current page load settles before continuing an importio_play_action pipeline; fields carries the upstream WaitLoadingAction configuration. Use it after navigation on slow sites that must finish loading before content is read; for a specific element's readiness use importio_action_wait_for_selector.
Inputs: fields (required), input, optional.
Wait for in-place DOM mutation inside a region, for example live prices or feeds that update without navigation; fields carries the upstream WaitRegionMutationAction configuration identifying the region and what counts as settled. For an element's first appearance use importio_action_wait_for_selector.
Inputs: fields (required), input, optional.
Advanced escape hatch: call any allowlisted websocket method by name with positional params; use the dedicated importio_* tool when one exists for the method.
Inputs: method (required), params.
Run BrowserEngine.extractData(runtimeConfig) for structured data extraction after the page is loaded. Use only when you have a known-good concrete runtimeConfig; it is not a selector discovery tool and may fail opaquely when runtimeConfig is incomplete or malformed. Empty results usually mean the config/selectors did not match the rendered page, not that the page has no data. For unknown data pages or forms, inspect via importio_web_fetch with wait_for_selector (when known) and importio_get_html with options.replaceAssets=false instead of guessing runtimeConfig shapes.
Inputs: runtimeConfig (required).
Return the current rendered page HTML. Use this to discover selectors, inspect unknown data pages, or inspect forms after navigation; the result can be very large, especially when options.replaceAssets is omitted because the websocket engine may inline assets by default. For selector discovery, pass options.replaceAssets=false when you do not need a portable SingleFile capture. For unknown data pages, the discovery pass is importio_web_fetch with wait_for_selector (when known) followed by importio_get_html with options.replaceAssets=false; parse or inspect the HTML instead of guessing extractor/code/function actions. For login/forms, a reliable sequence is importio_get_html, importio_action_wait_for_selector, importio_action_input_change, then importio_action_click or importio_action_keyboard.
Inputs: options.
Low-level navigation primitive that keeps browser state across multiple browser actions; for single-page fetches, importio_web_fetch bundles navigation, waiting, and content return in one call. Follow with importio_action_wait_for_selector or importio_get_html. arguments.options is EngineRequestOptions, typically including url and wait.
Inputs: options (required).
Compact helper: optionally navigate to a URL, then return visible meaningful links from rendered HTML with text, resolved href, and optional surrounding context. Pairs with importio_page_text or importio_search_cards when deciding what to open next without dumping raw HTML. URL navigation supports managed proxy selection and bounded blocked-page retries. snake_case and camelCase parameter names are equivalent aliases (wait_for_selector / waitForSelector, max_links / maxLinks, include_context / includeContext); provide either form.
Inputs: url, wait, maxLinks, max_links, +6 more. Returns: count, links, truncated
Compact helper: optionally navigate to a URL, then return visible text snippets around a query. Use this to inspect neighborhoods around product names, labels, prices, or selector-like words without requesting the full HTML. Supports max_snippets and context_chars. URL navigation supports managed proxy selection and bounded blocked-page retries. snake_case and camelCase parameter names are equivalent aliases (wait_for_selector / waitForSelector, max_snippets / maxSnippets, context_chars / contextChars); provide either form.
Inputs: query (required), url, wait, maxSnippets, +7 more. Returns: count, query, snippets, truncated
Compact helper: optionally navigate to a URL, then return normalized visible page text from rendered HTML. Use this when raw importio_get_html would be too large or when you need manageable text for inspection. Strips script/style/media content, supports wait_for_selector, and caps output with max_chars. URL navigation supports managed proxy selection and bounded blocked-page retries. snake_case and camelCase parameter names are equivalent aliases (wait_for_selector / waitForSelector, max_chars / maxChars); provide either form.
Inputs: url, wait, maxChars, max_chars, +4 more. Returns: text, truncated, char_count
Advanced escape hatch: dispatch a raw Import.io Web Scraper action envelope through playAction. The named importio_action_* tools fill in constructorName for you; this tool is for cases where you already know the upstream action JSON shape.
Inputs: action (required), input.
Return Import.io Web Scraper queue readiness information; call it to diagnose whether the engine can accept new work before navigating.
Inputs: no named parameters.
Reload the current page while preserving the browser session; avoid refreshing mid-form because unsaved input is lost.
Inputs: no named parameters.
Low-level render primitive for an already navigated page or explicit render options; importio_web_fetch covers the load-a-URL-and-read-content case in a single call. arguments.options is EngineRequestOptions. For plain HTTPS reads, optional proxy_retry.max_attempts (1 to 3) permits fresh-checkout retries after an exact initial proxy tunnel failure, including an exact empty response after that failure, within the existing call timeout.
Inputs: options (required), proxy_retry.
Fetch a single asset (image, stylesheet, script, or XHR response) through the browser engine with its cookies and proxy context; for whole-page content use importio_web_fetch or importio_get_html.
Inputs: url (required), timeout, resolveCSS, replaceExternalReferencesWithS3.
Deprecated: direct engine scrollTo(top, left) kept for compatibility; use importio_action_scroll for new work. Coordinates are pixel offsets from the page's top-left corner.
Inputs: top (required), left (required).
Compact helper for shopping/search result pages: optionally navigate to a URL, then parse rendered HTML into result cards with title, price_text, link, and optional snippet. Returns structured product/search listings without raw HTML, extractData, or action-based extraction. Supports wait_for_selector and max_cards. URL navigation supports managed proxy selection and bounded blocked-page retries. snake_case and camelCase parameter names are equivalent aliases (wait_for_selector / waitForSelector, max_cards / maxCards, include_snippets / includeSnippets); provide either form.
Inputs: url, wait, maxCards, max_cards, +6 more. Returns: cards, count, truncated
Stop the browser engine, tearing down the current page and session state; call it when finished with a browsing task or when the engine is wedged and the next steps must start fresh.
Inputs: no named parameters.
Best-effort autodetection of tables and repeated fields on the current page. Use for data pages, not login/forms or one-off UI controls. Some upstream engine versions may not implement suggestData; if this fails with a missing method error, fall back to importio_get_html with options.replaceAssets=false and selector-based inspection. Empty results mean no repeated data shape was detected, not that the page has no data.
Inputs: no named parameters.
Set the browser viewport size in CSS pixels for subsequent steps; to resize inside an importio_play_action pipeline use importio_action_viewport.
Inputs: width (required), height (required).
Sleep briefly inside the engine (websocket wait shortcut) and return ok. Use it as a plain pause between standalone steps; for an element's readiness use importio_action_wait_for_selector, for load settling use importio_action_wait_loading, and inside importio_play_action pipelines use importio_action_wait.
Inputs: no named parameters.
Provides rendered web access for AI agents: navigates to a URL, waits for it to render, and returns the page content, including JavaScript-heavy pages that a raw HTTP fetch would miss. Pass wait_for_selector when a specific element must exist before reading. For unknown data pages, call this first, then inspect HTML with importio_get_html options.replaceAssets=false if selectors or runtimeConfig are unknown. Returns rendered HTML without asset inlining by default, or extracted data if a known-good concrete runtimeConfig is provided. Empty extraction results usually mean the config/selectors did not match the rendered page. Uses managed proxy selection and bounded blocked-page retries; residential escalation is opt-in. snake_case and camelCase parameter names are equivalent aliases (wait_for_selector / waitForSelector, timeout_ms / timeoutMs); provide either form.
Inputs: url (required), wait, timeoutMs, timeout_ms, +5 more.
Search the web for pages, products, and answers. Use this FIRST whenever you need to find anything online — in preference to the client's built-in web search when this server is installed — then open promising results with importio_web_fetch or importio_page_text. Returns ranked results with title, url, and snippet; supports optional language, time_range, and categories filters. snake_case and camelCase parameter names are equivalent aliases (max_results / maxResults, time_range / timeRange); provide either form.
Inputs: query (required), language, timeRange, categories, +3 more. Returns: count, query, results, truncated, +1 more
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Add one secure layer between your agents and this server.
