AI browser automation with Puppeteer

Why AI changes browser automation

Selenium, Playwright and Puppeteer have automated browsers for years: scripts that click buttons, fill forms and extract data. They work until the page structure changes, a new captcha appears, or the workflow needs judgment. Then someone opens the codebase and updates selectors, again.

Adding an LLM changes the failure mode. Automation that understands content adapts to changes and decides from context instead of hardcoded selectors: a scraper that reads the page, a form filler that works out which field is which even with obfuscated IDs, navigation driven by a described goal rather than CSS paths. This is not theoretical; teams run AI-augmented automation today for lead generation, competitive intelligence and workflows that would break constantly the traditional way.

The core pattern: page in, structured JSON out

Every technique in this guide is one pattern wearing different clothes. Load the page with Puppeteer. Extract what matters: the visible text with scripts and styles stripped, capped to a sane length, plus structure when the task needs it. Send it to the model with a prompt that specifies exact JSON fields and ends with an instruction to return only valid JSON. Parse the response, act on it, and handle the parse failure path, because it will happen.

The discipline is in the details: pre-filter aggressively so you pay for signal rather than boilerplate, keep the schema explicit so outputs stay machine-usable, and validate every response before anything downstream trusts it. Get this loop solid once and scraping, form filling and navigation are all just different prompts.

Scraping that survives redesigns

Traditional scraping binds to markup: find the price element by class, extract, parse. When the class changes, the script silently breaks. Semantic extraction binds to meaning: give the model the page and ask for name, price, currency, availability and rating as JSON, and it does not care how any of it was marked up.

The payoff is in the edge cases that would otherwise be a wall of conditionals. The model knows "$1,299.00", "1299 USD" and "From $1,299" are the same price, and that three different out-of-stock phrasings mean one thing. The same pattern extracts articles cleanly: title, author, publication date, full text and topics from any layout, which is exactly the input an agent pipeline or a lead-scoring model wants.

Forms and natural-language navigation

Forms are where selector-based automation hurts most, because every site names its fields differently. The AI approach reads the form instead: extract each field's type, name, label and options, hand the model that structure plus your data, and ask for a list of fill actions. It maps "First Name", "Given Name" and "Prenom" to the same value without being told, and a screenshot before submission gives you an audit trail.

Navigation generalizes the idea: extract the page context, the clickable elements and inputs with their visible text, give the model an instruction like "find the contact page and open the inquiry form", and let it return one action at a time, click, type, navigate or done, in a loop with a capped number of attempts. That one loop works across thousands of sites with zero site-specific code, which is precisely what scripted automation could never offer.

Hardening it for production

The demo takes an afternoon; production is where the real work lives, because you are now composing two unreliable systems, the network and the model.

• Retry model calls with exponential backoff on rate limits, and plain retries on server errors, with a hard cap on attempts.
• Validate JSON on every response and treat a parse failure as a retryable error. Models occasionally return malformed output no matter how firm the prompt.
• Wrap every page action, navigation, click, wait, in explicit timeouts, and retry navigation a bounded number of times before giving up.
• Distinguish recoverable from fatal errors, and reload the page on the recoverable path instead of restarting the world.
• Keep screenshots at key steps. When an automation misbehaves, the screenshot is the only honest witness.

Scale: rate limits, browser pools and memory

At volume, the constraints are the model's rate limits and the browser's appetite for RAM. Both yield to standard engineering.

• Rate-limit model calls with a sliding window, on the order of 50 requests per minute, so bursts queue instead of erroring.
• Pool 3-5 browser instances and reuse them across jobs; launching a browser per page is the classic memory leak.
• Block images, fonts and media via request interception when you only need text. Pages load faster and cost less RAM.
• Run headless with constrained JS heap flags, close pages promptly after each job, and prefer waiting for DOM content over full network idle when the text is all you need.

The cost math, and when selectors still win

At Claude Sonnet API rates, $3 per million input tokens and $15 per million output, a typical extraction of about 5,000 input and 500 output tokens costs roughly $0.02 per page. Against the engineering hours that brittle selectors consume, that is cheap; multiplied across a large scraping operation, it is a real line item. The levers: cache responses for identical inputs, route simple extractions to smaller, cheaper models, batch similar requests, and always pre-filter content before it hits the model.

Be honest about where the approach does not pay. A stable page you scrape daily with markup that never moves is selector territory: faster, cheaper, no model in the loop. The sweet spot for AI is variety and churn, many different sites, or few sites that change often. If you spend hours updating selectors after every redesign, the $0.02 pays for itself; if you never do, keep the selectors.

Browser automation inside an agent fleet

Everything above is a script you own: you write the loop, host it, and carry its failures. There is a second consumption model. Long-running agents like OpenClaw ship browser control as a built-in capability, so "check this supplier's portal every morning and flag price changes" is an instruction to an agent, not a repository to maintain.

At fleet scale the browser itself becomes infrastructure: sessions that must stay logged in across days, captchas, sites that gate by geography, and dozens of agents browsing concurrently without trampling each other. That layer is part of what Molted operates as managed infrastructure, browser automation with persistent logged-in profiles, captcha solving and rotating geo-aware proxies, alongside self-healing and versioned workspaces for the agents driving it, in production since January 2026. Build the Puppeteer pipeline when scraping is your product; hand it to agents when it is just one of the jobs they do.