Vibium Tutorial for Beginners (2026)

Vibium is a free, AI-native browser automation tool you can learn in one sitting: install it with pip install vibium or npm install vibium, then launch Chrome and script clicks, typing, and screenshots in about ten lines of code. Vibium ships as a single Go binary that auto-downloads Chrome for you, so there is no ChromeDriver to match and no Selenium Grid to configure. It was created by Jason Huggins, co-creator of Selenium and Appium, and runs on the modern WebDriver BiDi protocol with Python and JavaScript/TypeScript clients. This tutorial walks a complete beginner from an empty folder to a working script: you will install Vibium, open a real browser, find an element by CSS selector, click it, type into a form, and save a screenshot. Every element interaction auto-waits, so you skip the flaky sleep calls that trip up newcomers. By the end you will know the core commands and where to go next.

What is Vibium and why learn it in 2026?

Vibium is an open-source browser automation library that drives Chrome over WebDriver BiDi, the bidirectional protocol that replaced the old request-response WebDriver wire. It is the newest tool in a lineage that runs from Selenium to Playwright, and it was built by the person who started that lineage.

The reason it is worth learning now is setup friction, or the lack of it. With classic Selenium you install a language binding, download a matching ChromeDriver, and keep the two in sync every time Chrome updates. Vibium collapses all of that into one binary that manages the browser itself.

Three facts define Vibium and shape everything in this tutorial:

• Single Go binary. One download drives the whole thing and auto-fetches Chrome for Testing on first run.
• AI-native. A built-in MCP server lets AI agents call Vibium as a tool, and the API includes plain-English methods.
• Free and open. pip install vibium or npm install vibium, current version 26.2, source at github.com/VibiumDev/vibium.

For the full background, read What Is Vibium?. This site is an independent learning hub for the tool, not its vendor.

What is the Vibium beginner workflow?

The beginner workflow is a short pipeline: install Vibium, launch a browser, find an element, act on it, then read the result or capture a screenshot. Every script you write as a newcomer follows this same shape.

Hold this diagram in mind as you read. The rest of the tutorial is just these five stages filled in with real commands. Once the loop is familiar, more advanced features like network interception and AI verification slot on top of it without changing the basics.

What do I need before I start?

You need one runtime installed: Python 3.9 or newer, or Node.js 18 or newer. That is the only prerequisite, because Vibium supplies the browser itself. Check what you have:

python3 --version   # need 3.9 or higher
node --version      # need v18 or higher

If neither is present, install Python from python.org or Node from nodejs.org, choosing the LTS build. You do not need to install Chrome, ChromeDriver, or any WebDriver binary in advance. Vibium downloads Chrome for Testing automatically the first time you launch a browser.

How do I install Vibium?

Install Vibium with a single command, then confirm it works with a three-line script. Pick the language you are most comfortable with; the underlying engine is identical either way.

Install for Python

Use a virtual environment so the dependency stays isolated from your system Python:

mkdir vibium-tutorial
cd vibium-tutorial
python3 -m venv .venv
source .venv/bin/activate     # Windows: .venv\Scripts\activate
pip install vibium

Confirm the install by launching and closing a browser:

from vibium import browser_sync as browser
 
vibe = browser.launch()
vibe.go("https://example.com")
vibe.quit()

The first launch() triggers a one-time Chrome for Testing download, so give it a moment that first run.

Install for Node

Initialize a package.json so npm records the dependency, then install:

mkdir vibium-tutorial
cd vibium-tutorial
npm init -y
npm install vibium

TypeScript types ship in the same package, so there is no extra @types step. Verify with a quick script:

const { browser } = require("vibium/sync");
 
const bro = browser.launch();
const page = bro.page();
page.go("https://example.com");
bro.close();

If you hit an error here, the full install guide covers platform-specific fixes. Otherwise, you are ready to write a real script.

How do I write my first Vibium script?

Your first script launches Chrome, opens a page, reads a link, saves a screenshot, and clicks the link. This is the complete beginner loop in one file.

Create hello.js and paste this:

const fs = require("fs");
const { browser } = require("vibium/sync");
 
// 1. Launch Chrome and grab the default tab
const bro = browser.launch();
const page = bro.page();
 
// 2. Navigate to a page (waits for load)
page.go("https://example.com");
console.log("Loaded example.com");
 
// 3. Find an element by CSS selector
const link = page.find("a");
console.log("Link text:", link.text());
 
// 4. Save a screenshot — screenshot() returns PNG bytes
fs.writeFileSync("example.png", page.screenshot());
console.log("Saved example.png");
 
// 5. Click the link, then close the browser
link.click();
bro.close();
console.log("Done");

Run it:

node hello.js

Chrome opens, loads example.com, prints the link text, writes example.png to your folder, clicks the link, and closes. That is the entire five-stage pipeline in action.

Here is the same script in Python, using the sync client this site uses throughout:

from vibium import browser_sync as browser
 
# 1. Launch Chrome
vibe = browser.launch()
 
# 2. Navigate
vibe.go("https://example.com")
print("Loaded example.com")
 
# 3. Find an element
link = vibe.find("a")
print("Link text:", link.text())
 
# 4. Screenshot — returns PNG bytes
with open("example.png", "wb") as f:
    f.write(vibe.screenshot())
print("Saved example.png")
 
# 5. Click and quit
link.click()
vibe.quit()
print("Done")

Run it with python3 hello.py. The behavior is identical to the JavaScript version.

What does each command do?

Each Vibium call maps to exactly one browser action, which is what makes scripts easy to read at a glance. Here is the beginner core:

In Python's sync client the page methods live directly on the object returned by launch(), so you call vibe.go() and vibe.find() without a separate page() step. In JavaScript you first get the tab with bro.page(). That is the main surface difference between the two clients for a beginner.

How do I find elements on a page?

Use page.find() with a CSS selector to locate a single element, and page.findAll() when you expect several. CSS selectors cover roughly 80% of everyday cases, and they are the fastest thing to learn first.

page.find("#email");                 // by id
page.find(".btn-primary");           // by class
page.find("input[name='q']");        // by attribute
page.find("nav a");                  // descendant combinator

Vibium also supports semantic finding by passing an object instead of a string, which is closer to how a user perceives the page:

page.find({ role: "button", text: "Sign in" });   // ARIA role + text
page.find({ label: "Email" });                     // by form label
page.find({ placeholder: "Search..." });           // by placeholder

In Python those become keyword arguments, which read very cleanly:

vibe.find(role="button", text="Sign in")
vibe.find(label="Email")

The object form is a genuine convenience: combining a role with visible text in one call is something older tools make you chain together. For a deeper reference on selectors and matching, see the find element command.

Why don't I need to add waits?

Vibium auto-waits because its Go engine runs actionability checks before every interaction. Before clicking or typing, it polls until the target element is present, visible, stable, and able to receive the event, then acts. You do not sprinkle sleep(2) calls to fight timing bugs.

This matters most for beginners, because manual waits are the single biggest source of flaky first scripts. A button that is still animating in, or a field that is briefly disabled, would break a naive script; Vibium simply waits for it to become ready.

const box = page.find("textarea[name='q']");
box.type("vibium browser automation");   // waits until the field is editable

There is no polling loop and no stale-element retry to write. The waiting is enforced server-side in the binary, so it behaves the same across Python and JavaScript. Actionability is one of Vibium's defining behaviors, and it is why the scripts above have no timing code at all.

How do I automate a login form?

A login is the classic first "real" task: find two fields, type into them, and click submit. It uses only the commands you have already seen. Here is the shape in JavaScript:

const { browser } = require("vibium/sync");
 
const bro = browser.launch();
const page = bro.page();
page.go("https://practice.example.com/login");
 
page.find("#username").type("test_user");
page.find("#password").type("secret_pass");
page.find({ role: "button", text: "Log in" }).click();
 
// Read a result on the next page
console.log(page.find(".welcome").text());
 
bro.close();

Each find() auto-waits, so you do not need a pause between typing the password and clicking submit. For a complete, verified walkthrough including how to confirm you landed on the right page afterward, follow Automate a login with Vibium.

How do I scrape data from a page?

Scraping in Vibium is the same loop with findAll() in place of find(): locate every matching element, then read text or an attribute from each. This is the other task most beginners reach for, and it needs no new concepts.

from vibium import browser_sync as browser
 
vibe = browser.launch()
vibe.go("https://quotes.toscrape.com")
 
# findAll returns a list of elements
quotes = vibe.find_all(".quote .text")
for q in quotes:
    print(q.text())
 
vibe.quit()

The JavaScript version reads almost identically:

const { browser } = require("vibium/sync");
 
const bro = browser.launch();
const page = bro.page();
page.go("https://quotes.toscrape.com");
 
const quotes = page.findAll(".quote .text");
for (const q of quotes) {
  console.log(q.text());
}
 
bro.close();

To pull an attribute rather than text, call el.attr("href") on each element. A key beginner detail: findAll() returns immediately with whatever matches right now (an empty list if nothing matches), so if the data loads after a delay, wait for the container first with page.waitFor(".quote") before collecting. That single habit prevents most "why is my list empty?" confusion when scraping dynamic pages.

Should I use the sync or async API?

Use the synchronous API while you are learning, because it reads top to bottom with no await and matches every example above. Vibium also ships an async API for code that lives inside an existing promise-based or asyncio codebase.

// Async JavaScript
const { browser } = require("vibium");
 
async function main() {
  const bro = await browser.launch();
  const page = await bro.page();
  await page.go("https://example.com");
  await page.find("a").click();
  await bro.close();
}
 
main();

# Async Python
import asyncio
from vibium.async_api import browser
 
async def main():
    bro = await browser.launch()
    vibe = await bro.new_page()
    await vibe.go("https://example.com")
    await bro.close()
 
asyncio.run(main())

The rule of thumb: sync for scripts and learning, async when you are already in an async application or need concurrency. The sync vs async guide breaks down the trade-offs in detail.

How does Vibium compare to other tools for a beginner?

For a newcomer, the meaningful differences are setup effort, protocol, and whether AI features come built in. Vibium's pitch is the smallest first-run setup plus native AI hooks; the mature tools trade some setup for larger ecosystems and cross-browser reach. Here is an honest at-a-glance comparison.

When to choose Vibium: you want the fastest path to a working script, you are targeting Chrome, or you plan to let an AI agent drive the browser through the MCP server.

When to choose Selenium: you need mature, battle-tested cross-browser support across many languages, or you are in an enterprise already standardized on it.

When to choose Playwright: you need cross-browser coverage today (Chromium, Firefox, WebKit) with a large, stable ecosystem and a bundled test runner.

None of these is strictly "best." Vibium is the newest and leanest with AI built in; the others are more mature and broader. Read the full Vibium vs Playwright and Vibium vs Selenium breakdowns before deciding, and note the honest gotcha: as a young project, Vibium's browser and language coverage is still narrower than the incumbents.

How do I let an AI drive the browser?

Because Vibium bundles an MCP server, an AI coding assistant can call it as a tool and automate the browser from plain-English instructions. This is the feature that most sets Vibium apart for beginners in 2026.

Add it to Claude Code with one command:

claude mcp add vibium -- npx -y vibium mcp

Now you can ask the assistant to open a site, fill a form, or check a page, and it uses Vibium's own deterministic commands under the hood. It is AI planning the steps, not blindly puppeteering. The full setup, including Gemini CLI, is in Vibium MCP with Claude Code.

What should I learn after the basics?

Once the five-stage loop feels natural, the next things to pick up are screenshots for debugging, structuring code so it scales, and running headless in CI. Screenshots are your fastest debugging tool: call page.screenshot() at any point to see exactly what the browser saw.

To keep growing scripts maintainable, learn the Page Object Model, which groups selectors and actions per page instead of scattering them. When you are ready to run without a visible window, launch headless:

const bro = browser.launch({ headless: true });

vibe = browser.launch(headless=True)

Unfamiliar term along the way? The Vibium glossary defines BiDi, actionability, MCP, and the rest in plain language.

What are the most common beginner errors?

Most first-time Vibium problems come from the runtime or the project folder, not from Vibium itself. Here are the ones newcomers hit most often and the one-line fix for each.

On Linux, the one-time library install looks like this:

sudo apt-get install -y libgbm1 libnss3 libatk-bridge2.0-0 libdrm2 \
  libxkbcommon0 libxcomposite1 libxdamage1 libxfixes3 libxrandr2 libasound2

When something goes wrong mid-script, your best move is to capture what the browser actually saw. Drop a page.screenshot() right before the failing line and open the PNG. Nine times out of ten the screenshot shows a cookie banner, a not-yet-loaded page, or a selector that points at the wrong element, and the fix becomes obvious. Running headed (the default) while you learn also lets you watch the browser and spot the problem live.

Next steps

You have installed Vibium, launched a browser, found and clicked elements, typed into a form, and saved a screenshot — the complete beginner toolkit. Keep going:

• What Is Vibium? — the full picture of the tool and its design
• How to Install Vibium — platform-specific setup and fixes
• Your first Vibium script in JavaScript — a focused JS quickstart
• The find element command — every selector strategy in one place
• The screenshot command — capture pages and single elements
• Automate a login with Vibium — your first real end-to-end task
• Vibium MCP with Claude Code — let an AI drive the browser
• The Vibium roadmap and learning course — a structured path from here