Chrome Just Killed 8 Of My 12 Puppeteer Scrapers

Google I/O 2026 shipped three Chrome updates that made two-thirds of my production scraping code obsolete overnight. I run browser automation for bookkeeping SMBs — receipts pulled from vendor portals, PDFs OCR'd, line items pushed to accounting software. Last week I opened my scraper repo, ran the tally against the new Chrome primitives, and cut eight of twelve scripts. Here's exactly what died, what survived, and which SaaS categories on your invoice list are on borrowed time.

The tally: 12 scrapers in, 4 scrapers out

Before the updates, my repo had twelve Puppeteer scripts in production. Each one was a small business — logging into a supplier portal, downloading invoices or receipts, extracting line items, pushing them to the client's books. After migrating to Chrome primitives on cooperating sites, four scripts remain. The other eight are archived.

Scraper category	Count before	Count after	Killed by
Portals with hidden JSON endpoints	5	0	WebMCP
PDF OCR + classification pipelines	3	0	Built-in AI (Gemini Nano)
Multi-step login/download/reconcile	0	0	Skills in Chrome (folded in)
Hostile portals (rotating selectors, captchas)	4	4	Nothing. Still Puppeteer + proxies.
Total	12	4

Zero code from me on the eight I killed. Google shipped the replacement into a browser update. The rest of this post walks through each primitive, what it actually replaces, and how to run the same audit on your own SaaS bill.

WebMCP replaces the "reverse-engineer the hidden JSON" scraper

WebMCP lets a site expose tools directly to a browser agent through a standard protocol — an API contract that lives inside the page. Instead of your agent parsing HTML, clicking buttons, and praying the DOM didn't change, the site declares what actions exist and what data comes back. On cooperating sites, this replaces every scraper whose job was to reverse-engineer the network tab and hit undocumented JSON endpoints.

Five of my twelve scrapers were doing exactly that. Here's what one of them looked like before:

// Old: Puppeteer chasing a hidden endpoint
await page.goto('https://vendor-portal.example.com/invoices');
await page.waitForSelector('#invoice-table');

// Intercept the XHR the table fires internally
const invoicesJson = await page.evaluate(async () => {
  const res = await fetch('/api/v3/invoices?range=90d', {
    credentials: 'include',
    headers: { 'X-CSRF-Token': window.__csrf }
  });
  return res.json();
});

// Handle pagination, 429s, DOM shape changes, session expiry...

That script broke on average every 6-8 weeks whenever the vendor rotated their CSRF pattern or added a rate-limit header. The WebMCP version, on a cooperating portal:

// New: ask the site what it offers
const tools = await chrome.webmcp.listTools(tabId);
// -> [{ name: 'list_invoices', params: { range: 'string' } }, ...]

const invoices = await chrome.webmcp.callTool(tabId, 'list_invoices', {
  range: '90d'
});

No DOM parsing. No CSRF chasing. No breakage when the vendor redesigns their UI, because the contract is the tool declaration, not the HTML. Every SaaS that priced itself on "we handle DOM changes for you" just lost its moat on cooperating sites.

What WebMCP does not fix

• Sites that refuse to publish tools (any adversarial portal — banks, government, hostile suppliers).
• Auth flows behind SSO providers that block automated user agents.
• Anything that requires captcha solving.

Built-in AI collapses the OCR + classification middle layer

Gemini Nano now runs on-device inside Chrome. That means OCR, classification, entity extraction, and simple structuring happen locally with no API bill and no network hop. Three of my scrapers existed only to shuttle downloaded PDFs through a cloud OCR pipeline (roughly $0.015 per page at my volume) and then run a classifier to tag vendor line items. That entire middle layer collapses into a browser call.

The old flow, per receipt:

Download PDF (Puppeteer)
  → Upload to Google Document AI ($0.015/page)
  → GPT-4o-mini for line item classification (~$0.002/receipt)
  → Structured JSON to Postgres
Cost: ~$0.017/receipt × 1,800/month = $30.60/month, plus 2-4s latency per receipt.

The new flow:

// Chrome Built-in AI, on-device
const session = await window.ai.assistant.create({
  systemPrompt: 'Extract line items from receipts. Return JSON: [{vendor, date, amount_usd, category}]'
});

const pdfText = await window.ai.ocr.extract(pdfBlob);
const items = JSON.parse(await session.prompt(pdfText));

Cost: $0. Latency: 400-900ms per receipt on the client's laptop CPU. No data leaves the machine, which happens to be a nice side effect for accountants who don't want client receipts hitting a third-party OCR vendor.

The catch: Gemini Nano is small. It handles structured extraction and clean OCR well. It falls over on multi-column receipts, low-contrast phone photos, and anything requiring reasoning across multiple pages. For those, I still route to a cloud model. But that's maybe 8% of receipts, not 100%.

Skills chain the workflow, so RPA-style scripting goes away

Skills in Chrome let an agent chain multi-step workflows on a site — log in, navigate, download, reconcile — as a single reusable unit. This is the piece that replaces the "click bot" category: RPA tools, form-fillers, onboarding automation platforms. On any site that publishes a Skill (or that cooperates enough that you can define one), you stop writing selector-based scripts.

A skill definition for a bookkeeping workflow looks roughly like this:

name: monthly_vendor_reconcile
inputs:
  - vendor_id: string
  - month: string  # YYYY-MM
steps:
  - login_with_saved_credentials
  - navigate: /vendors/{vendor_id}/statements
  - download_statement: { month: {month} }
  - extract_line_items          # uses Built-in AI
  - reconcile_against: quickbooks.vendor_ledger
outputs:
  - reconciliation_report

That replaces roughly 180 lines of Puppeteer per vendor in my old repo. The agent knows how to handle intermediate failures (retry the download, re-auth if the session expired, flag the report if amounts don't tie). I don't write that logic anymore.

Skills need site cooperation to work reliably. On a hostile portal, a Skill will fail exactly the same way a Puppeteer script fails — selectors change, captchas fire, the account gets flagged. Which brings us to what survived.

What Chrome did not kill: the 4 hostile-portal scrapers

Four of my twelve scrapers hit portals run by companies that actively don't want to be scraped. Rotating selectors on every deploy. Captchas that trigger on the second request from any IP. User-agent fingerprinting. These sites will never publish a WebMCP tool declaration or a Skill, because their business model depends on friction.

Those four scripts still run on Puppeteer with:

• Residential proxy rotation ($75/month for the pool I use)
• Stealth plugin patches for headless detection
• Manual captcha budget (~$4/month at current volume)
• A dedicated retry queue because success rate hovers at 82-88%

Total operating cost for the four survivors: about $110/month, plus the maintenance tax of rewriting a selector or two every couple of weeks. That's the market that stays profitable for scraping vendors. It's smaller, uglier, and more industry-specific than the cooperating-portal market — but it's the one that actually pays a premium, because the alternative for the customer is a human doing data entry.

Which SaaS line items to cut this week

Three categories on your monthly invoice list just had their moat drained. If you're paying for any of these against cooperating sites, you're on borrowed time:

• RPA bots that click through vendor portals — UiPath-lite tools, Automation Anywhere for SMB, low-code "click recorder" platforms typically running $80-400/month.
• Form-fillers and onboarding automators — anything that pretends to be a user typing into a form.
• Browser automation platforms that charge per run — Browse AI, Apify starter tiers, Zapier's browser actions add-on, custom scraping-as-a-service vendors.

Run this audit against your last three invoices:

1. List every SaaS labeled browser automation, web scraping, RPA, form filler, workflow bot.
2. For each, name the specific site(s) it hits.
3. Ask one question per site: does the site cooperate, or does it fight back?
4. Cooperating → migration candidate. Cancel in Q1 2026 once your Chrome primitive replacement is stable.
5. Hostile → keep paying. That's a real moat.

For the cooperating half, budget a week per replacement. WebMCP and Skills migrations in my repo took 3-6 hours each including tests. That's cheaper than one month of what most of these tools charge.

The distribution story nobody is telling

Every I/O recap is calling this "the agentic web," like it's a philosophical shift. It isn't. It's a distribution shift. Google put agent tooling inside three billion browsers overnight. The venture-funded browser-agent startups raising at billion-dollar valuations to build what Chrome now includes are cooked. So are the SaaS wrappers that priced themselves on solving DOM fragility.

The winners are the thin wrappers that solve the four scrapers Chrome can't replace — the ones aimed at industries where portals fight back. Bookkeeping suppliers in emerging markets. Regional healthcare portals. Legal filing systems. Local government. That's a smaller, less sexy market than "AI agents for everyone," but it's the one where a customer will pay $200/month for a working tool because their only alternative is a $25/hour data entry contractor.

Where bizflowai.io fits

The bookkeeping automations we run for SMB clients at bizflowai.io sit exactly on this line. On cooperating platforms — QuickBooks, Stripe, most modern SaaS accounting exports — we're already migrating client integrations onto WebMCP and on-device extraction, which drops OCR costs to zero and removes the per-run browser automation fees clients used to pay. On hostile portals — the regional supplier sites and legacy vendor systems that fight scraping — we keep the Puppeteer + proxy stack, because that's the only thing that works and it's the layer where an automation partner still earns its keep. The audit process above is what we run for a client before quoting any new engagement.

---

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.