API Matrix
Every operation Vibium supports (235 in all) and its form on each surface. An empty cell means the surface has no equivalent. The source is the API spec in the main repository, which CI checks against the binary and all three clients.
Operations marked (nightly) are not in the latest release (26.11.16).
The same data is published as /api.json. Per-language
views: JavaScript,
Python, Java.
Browser
Section titled “Browser”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Launch browser and connect | vibium start | browser_start | browser.start(opts?) | browser.start(opts?) | Vibium.start(options?) |
| Get the default page | browser.page() | browser.page() | browser.page() | ||
| Create a new page | vibium page new | browser_new_page | browser.newPage() | browser.new_page() | browser.newPage() |
| Create a new browser context | browser.newContext() | browser.new_context() | browser.newContext() | ||
| List all pages | vibium pages | browser_list_pages | browser.pages() | browser.pages() | browser.pages() |
| Stop the browser | vibium stop | browser_stop | browser.stop() | browser.stop() | browser.stop() |
| Listen for new page events | browser.onPage(cb) | browser.on_page(cb) | browser.onPage(cb) | ||
| Listen for popup events | browser.onPopup(cb) | browser.on_popup(cb) | browser.onPopup(cb) | ||
| Remove all event listeners | browser.removeAllListeners(ev?) | browser.remove_all_listeners(ev?) | browser.removeAllListeners(ev?) | ||
| Get the default context | browser.context() |
| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Navigate to a URL | vibium go <url> | browser_navigate | page.go(url) | page.go(url) | page.go(url) |
| Go back | vibium back | browser_back | page.back() | page.back() | page.back() |
| Go forward | vibium forward | browser_forward | page.forward() | page.forward() | page.forward() |
| Reload page | vibium reload | browser_reload | page.reload() | page.reload() | page.reload() |
| Get current URL | vibium url | browser_get_url | page.url() | page.url() | page.url() |
| Get page title | vibium title | browser_get_title | page.title() | page.title() | page.title() |
| Get page HTML | page.content() | page.content() | page.content() | ||
| Find a single element by description (a bare string), css, tag, semantic locator, or reference image; strategy auto, cv, vlm, or tree | vibium find <description> | browser_find | page.find(locator, opts?) | page.find(locator, **opts) | page.find(locator, options?) |
| Find all matching elements, same locator forms | vibium find --all <description> | browser_find_all | page.findAll(locator, opts?) | page.find_all(locator, **opts) | page.findAll(locator, options?) |
| Take a page screenshot | vibium screenshot | browser_screenshot | page.screenshot(opts?) | page.screenshot(opts?) | page.screenshot(options?) |
| Generate PDF | vibium pdf | browser_pdf | page.pdf(opts?) | page.pdf(**opts) | page.pdf(options?) |
| Evaluate JavaScript | vibium eval <expr> | browser_evaluate | page.evaluate(expr) | page.evaluate(expr) | page.evaluate(expr) |
| Add a script tag | page.addScript(src) | page.add_script(src) | page.addScript(src) | ||
| Add a style tag | page.addStyle(src) | page.add_style(src) | page.addStyle(src) | ||
| Expose a function to the page | page.expose(name, fn) | page.expose(name, fn) | page.expose(name, fn) | ||
| Wait for a duration | vibium sleep <ms> | browser_sleep | page.wait(ms) | page.wait(ms) | page.sleep(ms) |
| Wait for a selector | vibium wait <sel> | browser_wait | page.waitFor(sel, options?) | ||
| Wait for JS function to return truthy | vibium wait fn <expr> | browser_wait_for_fn | page.waitForFunction(fn, opts?) | page.wait_for_function(fn, **opts) | page.waitForFunction(fn, options?) |
| Wait for URL to match | vibium wait url <pat> | browser_wait_for_url | page.waitForURL(url, opts?) | page.wait_for_url(url, **opts) | page.waitForURL(url, options?) |
| Wait for page load | vibium wait load | browser_wait_for_load | page.waitForLoad(opts?) | page.wait_for_load(**opts) | page.waitForLoad(options?) |
| Scroll the page | vibium scroll <dir> <amt> | browser_scroll | page.scroll(dir?, amt?, sel?) | page.scroll(dir?, amt?, sel?) | page.scroll(options?) |
| Set viewport size | vibium viewport <w> <h> | browser_set_viewport | page.setViewport(size) | page.set_viewport(size) | page.setViewport(size) |
| Get viewport size | vibium viewport | browser_get_viewport | page.viewport() | page.viewport() | page.viewport() |
| Override CSS media features | vibium media <scheme> | browser_emulate_media | page.emulateMedia(opts) | page.emulate_media(**opts) | page.emulateMedia(opts) |
| Set page HTML | vibium content <html> | browser_set_content | page.setContent(html) | page.set_content(html) | page.setContent(html) |
| Override geolocation | vibium geolocation <lat> <lon> | browser_set_geolocation | page.setGeolocation(coords) | page.set_geolocation(coords) | page.setGeolocation(coords) |
| Set window size/position | vibium window <opts> | browser_set_window | page.setWindow(opts) | page.set_window(**opts) | page.setWindow(opts) |
| Get window info | vibium window | browser_get_window | page.window() | page.window() | page.window() |
| Get accessibility tree | vibium a11y-tree | browser_a11y_tree | page.a11yTree(opts?) | page.a11y_tree(opts?) | page.a11yTree(options?) |
| List all frames | vibium frames | browser_frames | page.frames() | page.frames() | page.frames() |
| Get a frame by name/URL | vibium frame <ref> | browser_frame | page.frame(nameOrUrl) | page.frame(name_or_url) | page.frame(nameOrUrl) |
| Get the main frame | page.mainFrame() | page.main_frame() | page.mainFrame() | ||
| Bring page to front | vibium page switch <idx> | browser_switch_page | page.bringToFront() | page.bring_to_front() | page.bringToFront() |
| Close the page | vibium page close | browser_close_page | page.close() | page.close() | page.close() |
| Register a route handler | page.route(pattern, handler) | page.route(pattern, handler) | page.route(pattern, handler) | ||
| Remove a route handler | page.unroute(pattern) | page.unroute(pattern) | page.unroute(pattern) | ||
| Set extra HTTP headers | page.setHeaders(headers) | page.set_headers(headers) | page.setHeaders(headers) | ||
| Listen for requests | page.onRequest(fn) | page.on_request(fn) | page.onRequest(fn) | ||
| Listen for responses | page.onResponse(fn) | page.on_response(fn) | page.onResponse(fn) | ||
| Listen for dialogs | page.onDialog(fn) | page.on_dialog(fn) | page.onDialog(fn) | ||
| Listen for console messages | page.onConsole(fn) | page.on_console(fn) | page.onConsole(fn) | ||
| Listen for page errors | page.onError(fn) | page.on_error(fn) | page.onError(fn) | ||
| Listen for downloads | page.onDownload(fn) | page.on_download(fn) | page.onDownload(fn) | ||
| Subscribe to WebSocket events | page.onWebSocket(fn) | page.on_web_socket(fn) | page.onWebSocket(fn) | ||
| Remove all event listeners | page.removeAllListeners(ev?) | page.remove_all_listeners(ev?) | page.removeAllListeners(ev?) | ||
| Capture response (before action) | page.capture.response(pat, fn?) | page.capture.response(pat, fn?) | page.capture().response(pat, action) | ||
| Capture request (before action) | page.capture.request(pat, fn?) | page.capture.request(pat, fn?) | page.capture().request(pat, action) | ||
| Capture navigation (before action) | page.capture.navigation(fn?) | page.capture.navigation(fn?) | page.capture().navigation(action) | ||
| Capture event (before action) | page.capture.event(name, fn?) | page.capture.event(name, fn?) | page.capture().event(name, action) | ||
| Capture download (before action) | page.capture.download(fn?) | page.capture.download(fn?) | page.capture().download(action) | ||
| Capture dialog (before action) | page.capture.dialog(fn?) | page.capture.dialog(fn?) | page.capture().dialog(action) | ||
| Get buffered console messages | page.consoleMessages() | page.console_messages() | page.consoleMessages() | ||
| Get buffered page errors | page.errors() | page.errors() | page.errors() | ||
| Owning browser context | page.context | page.context | page.context() | ||
| Browsing context id | page.id | page.id | page.id() | ||
| One-shot capture namespace | page.capture | page.capture | page.capture() | ||
| Keyboard input for the page | page.keyboard | page.keyboard | page.keyboard() | ||
| Mouse input for the page | page.mouse | page.mouse | page.mouse() | ||
| Touch input for the page | page.touch | page.touch | page.touch() | ||
| Clock control for the page | page.clock | page.clock | page.clock() | ||
| Deprecated alias for the wait helpers | page.waitUntil(fn, opts?) | page.wait_until | |||
| Enable console collect mode | mode of onConsole(‘collect’) | mode of on_console(‘collect’) | page.collectConsole() | ||
| Enable error collect mode | mode of onError(‘collect’) | mode of on_error(‘collect’) | page.collectErrors() | ||
| Intercept WebSockets (unsupported: throws) | page.routeWebSocket(pattern, fn) | ||||
| Alias for evaluate | page.eval(expr) |
Element
Section titled “Element”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Click an element | vibium click <sel> | browser_click | el.click(opts?) | el.click(timeout?) | el.click() |
| Double-click an element | vibium dblclick <sel> | browser_dblclick | el.dblclick(opts?) | el.dblclick(timeout?) | el.dblclick() |
| Fill an input field | vibium fill <sel> <val> | browser_fill | el.fill(value, opts?) | el.fill(value, timeout?) | el.fill(value) |
| Type text character by character | vibium type <text> | browser_type | el.type(text, opts?) | el.type(text, timeout?) | el.type(text) |
| Press a key on focused element | vibium press <key> | browser_press | el.press(key, opts?) | el.press(key, timeout?) | el.press(key) |
| Clear an input field | el.clear(opts?) | el.clear(timeout?) | el.clear() | ||
| Check a checkbox | vibium set <sel> | browser_set | el.set(value?, opts?) | el.set(value=True, timeout=...) | el.set(value?) |
| Uncheck a checkbox | vibium unset <sel> | browser_unset | el.unset(opts?) | el.unset(timeout?) | el.unset() |
| Select a dropdown option | vibium select <sel> <val> | browser_select | el.selectOption(val, opts?) | el.select_option(val, timeout?) | el.selectOption(val) |
| Hover over an element | vibium hover <sel> | browser_hover | el.hover(opts?) | el.hover(timeout?) | el.hover() |
| Focus an element | vibium focus <sel> | browser_focus | el.focus(opts?) | el.focus(timeout?) | el.focus() |
| Drag an element to a target | vibium drag <sel> <x> <y> | browser_drag | el.dragTo(target, opts?) | el.drag_to(target, timeout?) | el.dragTo(target) |
| Tap an element (touch) | el.tap(opts?) | el.tap(timeout?) | el.tap() | ||
| Scroll element into view | vibium scroll into-view <sel> | browser_scroll_into_view | el.scrollIntoView(opts?) | el.scroll_into_view(timeout?) | el.scrollIntoView() |
| Dispatch a DOM event | el.dispatchEvent(type, init?) | el.dispatch_event(type, init?) | el.dispatchEvent(type, init?) | ||
| Set files on a file input | vibium upload <sel> <paths> | browser_upload | el.setFiles(files, opts?) | el.set_files(files, timeout?) | el.setFiles(files) |
| Highlight an element | vibium highlight <sel> | browser_highlight | el.highlight() | el.highlight() | el.highlight() |
| Get element text content | vibium text <sel> | browser_get_text | el.text() | el.text() | el.text() |
| Get element inner text | vibium text <sel> | browser_get_text | el.innerText() | el.inner_text() | el.innerText() |
| Get element outer HTML | vibium html <sel> | browser_get_html | el.html() | el.html() | el.html() |
| Get input element value | vibium value <sel> | browser_get_value | el.value() | el.value() | el.value() |
| Get element attribute | vibium attr <sel> <name> | browser_get_attribute | el.attr(name) | el.attr(name) | el.attr(name) |
| Get element bounding box | el.bounds() | el.bounds() | el.bounds() | ||
| Bounding box (Playwright-compat alias for bounds) | el.boundingBox() | el.bounding_box() | el.boundingBox() | ||
| Get attribute (alias for attr) | el.getAttribute(name) | el.get_attribute(name) | el.getAttribute(name) | ||
| Find-time snapshot of tag, text, and box | el.info | el.info | el.info() | ||
| Check if element is visible | vibium is visible <sel> | browser_is_visible | el.isVisible() | el.is_visible() | el.isVisible() |
| Check if element is hidden | el.isHidden() | el.is_hidden() | el.isHidden() | ||
| Check if element is enabled | vibium is enabled <sel> | browser_is_enabled | el.isEnabled() | el.is_enabled() | el.isEnabled() |
| Check if element is checked | vibium is set <sel> | browser_is_set | el.isSet() | el.is_set() | el.isSet() |
| Check if element is editable | el.isEditable() | el.is_editable() | el.isEditable() | ||
| Get element ARIA role | el.role() | el.role() | el.role() | ||
| Get element accessible label | el.label() | el.label() | el.label() | ||
| Screenshot an element | el.screenshot() | el.screenshot() | el.screenshot() | ||
| Wait for element state | vibium wait <sel> --state <st> | browser_wait | el.waitUntil(state?, opts?) | el.wait_until(state?, timeout?) | el.waitUntil(state?, options?) |
| Find a child element (scoped) | el.find(sel, opts?) | el.find(sel, **opts) | el.find(sel, options?) | ||
| Find all child elements (scoped) | el.findAll(sel, opts?) | el.find_all(sel, **opts) | el.findAll(sel, options?) |
BrowserContext
Section titled “BrowserContext”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Create a page in a context | context.newPage() | context.new_page() | context.newPage() | ||
| Close the context | context.close() | context.close() | context.close() | ||
| Get cookies | vibium cookies | browser_get_cookies | context.cookies(urls?) | context.cookies(urls?) | context.cookies(urls?) |
| Set cookies | vibium cookies <n> <v> | browser_set_cookie | context.setCookies(cookies) | context.set_cookies(cookies) | context.setCookies(cookies) |
| Clear cookies | vibium cookies clear | browser_delete_cookies | context.clearCookies() | context.clear_cookies() | context.clearCookies() |
| Get storage state | vibium storage | browser_storage_state | context.storage() | context.storage() | context.storage() |
| Set storage state | browser_restore_storage | context.setStorage(state) | context.set_storage(state) | context.setStorage(state) | |
| Clear all storage | context.clearStorage() | context.clear_storage() | context.clearStorage() | ||
| Add an init script | context.addInitScript(script) | context.add_init_script(script) | context.addInitScript(script) | ||
| User context id | context.id | context.id | context.id() | ||
| Recording controls for the context | context.recording | context.recording | context.recording() |
Keyboard
Section titled “Keyboard”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Press a key | vibium keys <keys> | browser_keys | keyboard.press(key) | keyboard.press(key) | keyboard.press(key) |
| Key down | keyboard.down(key) | keyboard.down(key) | keyboard.down(key) | ||
| Key up | keyboard.up(key) | keyboard.up(key) | keyboard.up(key) | ||
| Type text | keyboard.type(text) | keyboard.type(text) | keyboard.type(text) |
| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Click at coordinates | vibium mouse click <x> <y> | browser_mouse_click | mouse.click(x, y, opts?) | mouse.click(x, y, **opts) | mouse.click(x, y, options?) |
| Move mouse | vibium mouse move <x> <y> | browser_mouse_move | mouse.move(x, y, opts?) | mouse.move(x, y, **opts) | mouse.move(x, y, options?) |
| Mouse button down | vibium mouse down | browser_mouse_down | mouse.down(opts?) | mouse.down(**opts) | mouse.down(options?) |
| Mouse button up | vibium mouse up | browser_mouse_up | mouse.up(opts?) | mouse.up(**opts) | mouse.up(options?) |
| Scroll mouse wheel | mouse.wheel(dx, dy) | mouse.wheel(dx, dy) | mouse.wheel(dx, dy) |
| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Tap at coordinates | vibium tap <x> <y> | browser_tap | touch.tap(x, y) | touch.tap(x, y) | touch.tap(x, y) |
| Swipe in a direction (up, down, left, right; from an edge or point; speed, hold) or between coordinates | vibium swipe <direction> | browser_swipe | touch.swipe(direction, opts?) | touch.swipe(direction, from_=, speed=, hold_ms=) | |
| Long-press at coordinates | vibium long-press <x> <y> | browser_long_press | touch.longPress(x, y, durationMs?) | touch.long_press(x, y, duration_ms?) |
| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Install fake timers | page_clock_install | clock.install(opts?) | clock.install(time?, timezone?) | clock.install(options?) | |
| Fast-forward time | page_clock_fast_forward | clock.fastForward(ticks) | clock.fast_forward(ticks) | clock.fastForward(ticks) | |
| Run timers for a duration | page_clock_run_for | clock.runFor(ticks) | clock.run_for(ticks) | clock.runFor(ticks) | |
| Pause clock at a time | page_clock_pause_at | clock.pauseAt(time) | clock.pause_at(time) | clock.pauseAt(time) | |
| Resume clock | page_clock_resume | clock.resume() | clock.resume() | clock.resume() | |
| Set fixed fake time | page_clock_set_fixed_time | clock.setFixedTime(time) | clock.set_fixed_time(time) | clock.setFixedTime(time) | |
| Set system time | page_clock_set_system_time | clock.setSystemTime(time) | clock.set_system_time(time) | clock.setSystemTime(time) | |
| Set timezone | page_clock_set_timezone | clock.setTimezone(tz) | clock.set_timezone(tz) | clock.setTimezone(tz) |
Recording
Section titled “Recording”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Start recording | vibium record start | browser_record_start | recording.start(opts?) | recording.start(opts?) | recording.start(options?) |
| Stop recording, return trace | vibium record stop | browser_record_stop | recording.stop(opts?) | recording.stop(path?, upload?) | recording.stop(path?) |
| Start a recording chunk | vibium record chunk start | browser_record_start_chunk | recording.startChunk(opts?) | recording.start_chunk(opts?) | recording.startChunk(options?) |
| Stop a recording chunk | vibium record chunk stop | browser_record_stop_chunk | recording.stopChunk(opts?) | recording.stop_chunk(path?) | recording.stopChunk(path?) |
| Start a logical group | vibium record group start <name> | browser_record_start_group | recording.startGroup(name, opts?) | recording.start_group(name, location?) | recording.startGroup(name, location?) |
| Stop a logical group | vibium record group stop | browser_record_stop_group | recording.stopGroup() | recording.stop_group() | recording.stopGroup() |
| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Access intercepted request | route.request (property) | route.request (property) | route.request() | ||
| Fulfill an intercepted request | route.fulfill(resp?) | route.fulfill(status?, headers?, ...) | route.fulfill(options?) | ||
| Continue an intercepted request | route.continue(overrides?) | route.continue_(overrides?) | route.doContinue(options?) | ||
| Abort an intercepted request | route.abort() | route.abort() | route.abort() |
Dialog
Section titled “Dialog”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Get dialog message | dialog.message() | dialog.message() | dialog.message() | ||
| Get dialog type | dialog.type() | dialog.type() | dialog.type() | ||
| Get dialog default value | dialog.defaultValue() | dialog.default_value() | dialog.defaultValue() | ||
| Accept the dialog | vibium dialog accept | browser_dialog_accept | dialog.accept(promptText?) | dialog.accept(prompt_text?) | dialog.accept(promptText?) |
| Dismiss the dialog | vibium dialog dismiss | browser_dialog_dismiss | dialog.dismiss() | dialog.dismiss() | dialog.dismiss() |
Download
Section titled “Download”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Save a download to path | download.saveAs(path) | download.save_as(path) | download.saveAs(path) | ||
| Get download URL | download.url() | download.url() | download.url() | ||
| Get download filename | download.suggestedFilename() | download.suggested_filename() | download.suggestedFilename() | ||
| Get download path | download.path() | download.path() | download.path() |
Request
Section titled “Request”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Get request URL | request.url() | request.url() | request.url() | ||
| Get HTTP method | request.method() | request.method() | request.method() | ||
| Get request headers | request.headers() | request.headers() | request.headers() | ||
| Get BiDi request ID | request.requestId() | request.request_id() | request.requestId() | ||
| Get request body | request.postData() | request.post_data() | request.postData() |
Response
Section titled “Response”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Get response URL | response.url() | response.url() | response.url() | ||
| Get HTTP status | response.status() | response.status() | response.status() | ||
| Get response headers | response.headers() | response.headers() | response.headers() | ||
| Get associated request ID | response.requestId() | response.request_id() | response.requestId() | ||
| Get response body | response.body() | response.body() | response.body() | ||
| Parse response body as JSON | response.json() | response.json() | response.json() |
ConsoleMessage
Section titled “ConsoleMessage”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Get console message type | message.type() | message.type() | message.type() | ||
| Get formatted message text | message.text() | message.text() | message.text() | ||
| Get console arguments | message.args() | message.args() | message.args() | ||
| Get source location | message.location() | message.location() | message.location() |
WebSocketInfo
Section titled “WebSocketInfo”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Get WebSocket URL | socket.url() | socket.url() | socket.url() | ||
| Listen for messages | socket.onMessage(fn) | socket.on_message(fn) | socket.onMessage(fn) | ||
| Listen for close | socket.onClose(fn) | socket.on_close(fn) | socket.onClose(fn) | ||
| Check whether socket is closed | socket.isClosed() | socket.is_closed() | socket.isClosed() |
Agent & CLI Extras
Section titled “Agent & CLI Extras”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Map interactive page elements with @refs | vibium map | browser_map | |||
| Diff page state vs last map | vibium diff map | browser_diff_map | |||
| Count elements matching selector | vibium count <sel> | browser_count | |||
| Wait for text to appear on page | vibium wait text <text> | browser_wait_for_text | |||
| Set the download directory | vibium download dir <path> | browser_download_set_dir | |||
| Start the background daemon | vibium daemon start | ||||
| Query daemon status | vibium daemon status | ||||
| Stop the background daemon | vibium daemon stop | ||||
| Print the version | vibium version | ||||
| Print browser and cache paths | vibium paths | ||||
| Download the browser engine | vibium install | ||||
| Check whether the engine is installed | vibium is-installed | ||||
| Run the BiDi websocket server | vibium serve | ||||
| Run the ndjson stdio transport | vibium pipe | ||||
| Run the MCP server | vibium mcp | ||||
| Install the agent skill | vibium add-skill | ||||
| Write a starter settings file | vibium config init | ||||
| Set up AI settings, agent skills, and the browser interactively | vibium setup | ||||
| Generate a script that replays a recording | vibium codegen -i <zip> | ||||
| Generate an Ed25519 Web Bot Auth signing key | vibium webbotauth keygen | ||||
| Print the Web Bot Auth JWKS directory to publish | vibium webbotauth directory | ||||
| Restore saved storage state | vibium storage restore <path> | ||||
| Print all actionability checks | vibium is actionable <sel> | ||||
| Find by ARIA role | vibium find role <val> | ||||
| Find by visible text | vibium find text <val> | ||||
| Find by label | vibium find label <val> | ||||
| Find by placeholder | vibium find placeholder <val> | ||||
| Find by alt text | vibium find alt <val> | ||||
| Find by title attribute | vibium find title <val> | ||||
| Find by test id | vibium find testid <val> | ||||
| Find by XPath | vibium find xpath <val> | ||||
| Find by CSS selector, explicitly | vibium find css <val> | ||||
| Find by HTML tag | vibium find tag <val> | ||||
| Find by description, explicitly | vibium find description <val> | ||||
| Find where a reference image appears | vibium find image <path> | ||||
| Diagnostic: launch the browser directly | vibium launch-test | ||||
| Diagnostic: test a websocket endpoint | vibium ws-test <url> | ||||
| Diagnostic: test a BiDi endpoint | vibium bidi-test <url> |
Run and Check
Section titled “Run and Check”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Independently verify the active session or a saved archive | vibium check <claim> | vibium_check | browser.check(claim, opts?) | browser.check(claim, record=...) | browser.check(claim, options?) |
| Independently verify a pinned page or a saved archive | page.check(claim, opts?) | page.check(claim, record=...) | page.check(claim, options?) | ||
| Check a saved archive without launching a browser | Vibium.check(claim, options) | ||||
| Check browser installation and configured AI readiness | vibium ready | ||||
| Require AI configuration and provider tool support | vibium ready ai | ||||
| Check local browser executable files without launching | vibium ready browser | ||||
| Send one phrase through the say and listen providers, without a browser | vibium ready speech | ||||
| Accomplish a goal in the active browser session | vibium run <goal> | vibium_run | browser.run(goal, opts?) | browser.run(goal, opts?) | browser.run(goal, opts?) |
| Accomplish a goal on a pinned page | page.run(goal, opts?) | page.run(goal, opts?) | page.run(goal, opts?) |
Say and Listen
Section titled “Say and Listen”| Operation | CLI | MCP | JavaScript | Python | Java |
|---|---|---|---|---|---|
| Speak text into the session, this machine’s speakers, or a WAV file | vibium say <text> | vibium_say | browser.say(text, opts?) | browser.say(text, target=...) | browser.say(text, options?) |
| Speak text into a pinned page | page.say(text, opts?) | page.say(text, target=...) | page.say(text, options?) | ||
| Hear the session, this machine’s microphone, or a WAV file, and return a transcript | vibium listen | vibium_listen | browser.listen(opts?) | browser.listen(target=...) | browser.listen(options?) |
| Hear a pinned page and return a transcript | page.listen(opts?) | page.listen(target=...) | page.listen(options?) | ||
| Speak with no browser, into this machine’s speakers or a WAV file | Vibium.say(text, options?) | ||||
| Listen with no browser, to this machine’s microphone or a WAV file | Vibium.listen(options?) |