iMacros Data Extraction: Browser Automation Tutorial

Ask Google's own extension update service for an extension ID and it answers in under a second. Either it hands back a version number and a download URL, or it hands back nothing. Asked for the iMacros for Chrome ID on 10 August 2026, it returns nothing to install. Asked for Ui.Vision and Web Scraper, two extensions doing much the same job, it returns packages and versions. That single request is the fastest honest answer to "does iMacros still work", and it is where this article now starts.

The macro language outlived the plugin, which is why the tutorial below is still worth your time. It is a compact way to describe a small extraction job, it still ships inside the paid desktop edition, and the one open-source successor with real traction offers to convert scripts written in it. What follows is the working part: the three commands that do almost all extraction, loop mode, driving a run from a CSV of inputs, and the walls you hit. Then the line-by-line translation of every macro pattern into a tool that shipped a release this month.

What is left of iMacros, checked on 10 August 2026

The vendor page is alive and frozen. Progress still markets iMacros, and the page still presents the 2021 release as the current one, "now with Chromium browser technology for supporting all modern websites". It claims more than ten million downloads and offers a 30-day trial. No price appears anywhere on it. The features page still describes three recording modes: TAG mode, which works from the underlying HTML, DirectScreen mode, which records mouse movement and keystrokes at screen level, and EVENT mode, a hybrid of the two.

The browser extensions are the part that died. You do not have to take anyone's word for it. Chrome's update service answers unauthenticated requests, so you can test any extension ID yourself:

https://clients2.google.com/service/update2/crx?response=updatecheck&prodversion=130&acceptformat=crx3&x=id%3DEXTENSION_ID%26v%3D0.0.0.0%26uc

Claiming version 0.0.0.0 forces the service to offer the newest build it has. These are the answers it gave on 10 August 2026:

The last row is the control, and it matters. Google distinguishes an unknown ID from a known one, so the iMacros answer is not "never heard of it". It is "known, and nothing to give you". The other three IDs, hit with identical parameters within the same minute, each produced a package.

Measured from one machine against Google's public update endpoint, with no browser and no account. It tells you what the update service will hand a browser, not what a store page renders for a signed-in user. Your results will carry different version numbers by the time you read this; the shape is what to look at.

Firefox is simpler: there is no listing. Searching addons.mozilla.org for iMacros returns 24 add-ons, and nothing called iMacros appears anywhere near the top of them. The old add-on page returns 404. What the search does surface is Ui.Vision, whose own listing text ends with the sentence "Conversion help for iMacros scripts is provided, too."

The documentation is gone, and this is the part that will cost you. The domain that hosted the iMacros command wiki, docs.imacros.net, no longer resolves in DNS at all. Progress's own documentation portal lists MarkLogic, OpenEdge, Sitefinity, Fiddler, Chef and a dozen more products, and no iMacros. Every old tutorial that says "see the wiki for the full parameter list" now points at nothing. The extension archive chrome-stats records the last Chrome build as version 10.1.1, published 24 November 2021, with roughly 471,000 weekly users at the time of its snapshot.

Two dates explain the wreckage, and one of them exonerates the obvious suspect. Internet Explorer, the browser this article was originally written for, ended support on 15 June 2022. Microsoft then had it "permanently disabled through a Microsoft Edge update on certain versions of Windows 10 on February 14, 2023". IE mode inside Edge is a different thing and is supported "through at least 2029". Chrome did the second piece of damage, by killing the extension platform iMacros was built on. Google's Manifest V2 timeline reads: 31 March 2025, disabled by default everywhere; 24 July 2025, with Chrome 138, "users can no longer turn them back on"; 31 August 2026, "all remaining Manifest V2 extensions are removed from the Chrome Web Store". That last date is three weeks after this sentence was written.

It is tempting to stop there and blame Manifest V2. The Selenium IDE row in the table above says otherwise. That extension is also a record-and-replay tool, its Firefox build has been frozen at 3.17.4 since 10 February 2022, and Chrome still serves it a package. Being old did not remove iMacros from the store. Being abandoned did.

A correction to the previous version of this article. It told you to install the iMacros extension from your browser's add-on store and pin it. That instruction has not worked for some time, and the sentence claiming iMacros "lives on as browser extensions for Chrome, Edge, and Firefox" is wrong as of August 2026. What survives is the paid desktop edition, which carries its own Chromium and therefore never depended on a store listing, and the macro language itself.

Why anyone recorded macros in the first place

The case for a recorder was never that it scaled. It was arithmetic on small jobs.

A twenty-page extraction with a stable table on each page costs about five minutes to record and edit. The same job written from scratch costs you a project directory, a dependency install, a browser driver, a selector hunt, and a first run that fails on something unrelated to the data. Call it forty minutes on a good day. For a task you will do once, the recorder wins by half an hour, and the person doing it does not need to know what a CSS selector is.

The break-even moves fast, though, and it moves in one direction. The moment the job repeats weekly, runs unattended, or grows past a few hundred pages, every minute the recorder saved gets spent watching it. A macro cannot tell you which of last night's 400 pages came back empty.

There is a second, quieter reason the format survived: a .iim macro is a plain text file. You can read it, diff it, and mail it to a colleague who can also read it. Most point-and-click scrapers store a project as opaque JSON in a vendor account, and the day the account lapses the work is gone. Six lines of text do not have that failure mode.

The commands that do the extraction

Three commands cover almost every extraction macro ever written.

URL GOTO navigates:

URL GOTO=https://example.com/products?page=1

TAG ... EXTRACT picks an element and pulls a value from it. You identify the element by position (POS), tag type (TYPE) and an attribute filter (ATTR), then say what to take:

TAG POS=1 TYPE=TABLE ATTR=CLASS:data-table EXTRACT=TXT

• EXTRACT=TXT takes the visible text.
• EXTRACT=HTM takes the inner HTML, which is what you want when the value hides in an attribute or a nested tag.
• EXTRACT=HREF takes a link target, and is the command that turns a listing page into a queue of detail-page URLs.

Suppress the popup iMacros shows after each extraction, or a batch run stops on the first one and waits for a human:

SET !EXTRACT_TEST_POPUP NO

SAVEAS TYPE=EXTRACT writes everything extracted so far to a file:

SAVEAS TYPE=EXTRACT FOLDER=* FILE=results.csv

FOLDER=* means the default download folder. Old tutorials hard-code c:\iMacros\Downloads, which was fine on one Windows box in 2012 and is a support ticket everywhere else.

A minimal single-page macro, in full:

VERSION BUILD=1030
TAB T=1
SET !EXTRACT_TEST_POPUP NO
URL GOTO=https://example.com/products?page=1
TAG POS=1 TYPE=TABLE ATTR=CLASS:data-table EXTRACT=TXT
SAVEAS TYPE=EXTRACT FOLDER=* FILE=results.csv

One warning about the fine print. The wiki that documented the exact separator behaviour of a whole-table extraction is the same wiki that no longer resolves. Anything you read about it now is somebody's memory of a page nobody can open. Run the macro once against your target, open the CSV, and believe the file rather than the tutorial. That goes double for tables with merged cells or nested markup.

Looping without copy-paste

Real jobs span pages. The clumsy version, which you will see in most macros published before 2015, repeats the extract-and-click block for each page:

TAG POS=1 TYPE=TABLE ATTR=CLASS:data-table EXTRACT=TXT
SAVEAS TYPE=EXTRACT FOLDER=* FILE=results.csv
TAG POS=1 TYPE=A ATTR=TXT:Next
WAIT SECONDS=2
TAG POS=1 TYPE=TABLE ATTR=CLASS:data-table EXTRACT=TXT
SAVEAS TYPE=EXTRACT FOLDER=* FILE=results.csv
TAG POS=1 TYPE=A ATTR=TXT:Next

It works until the site gains a page, at which point you edit the macro. Write the block once instead and let the player repeat it. The built-in counter {{!LOOP}} starts at 1 and increments on each pass, so if page number lives in the URL you never touch the Next link:

VERSION BUILD=1030
TAB T=1
SET !EXTRACT_TEST_POPUP NO
URL GOTO=https://example.com/products?page={{!LOOP}}
WAIT SECONDS=1
TAG POS=1 TYPE=TABLE ATTR=CLASS:data-table EXTRACT=TXT
SAVEAS TYPE=EXTRACT FOLDER=* FILE=results.csv

Set the repeat count to 20 and it walks pages 1 to 20, appending as it goes. Changing the range is one number.

This is where quiet data loss lives. The loop counts, it does not check. Point it at 50 pages when the listing has 31 and it will happily request pages 32 to 50, extract whatever the site returns for an out-of-range page, and append that to the same CSV. Sites answer an out-of-range page however their developer felt that day: an empty table, a copy of the last page, or a redirect back to page 1. The second and third produce duplicate rows that look exactly like real data. Sort the finished file by your key column and count duplicates before you use it, every time.

WAIT SECONDS=1 deserves the same suspicion. It is a bet that the page is ready, priced in seconds you pay on every single iteration whether you needed them or not. One wasted second across a 10,000-page run is close to three hours.

Driving a run from a list of inputs

To scrape by keyword, product ID or postcode, point iMacros at a CSV with SET !DATASOURCE and reference columns as {{!COL1}}, {{!COL2}} and so on. In loop mode the counter picks the row:

VERSION BUILD=1030
SET !DATASOURCE inputs.csv
SET !DATASOURCE_LINE {{!LOOP}}
SET !EXTRACT_TEST_POPUP NO
URL GOTO=https://example.com/search?q={{!COL1}}
WAIT SECONDS=1
TAG POS=1 TYPE=DIV ATTR=CLASS:result-title EXTRACT=TXT
SAVEAS TYPE=EXTRACT FOLDER=* FILE=results.csv

Each pass searches for the next term and saves what it finds. That is a keyword scraper in eight lines with no code, and it is the single pattern that kept iMacros in offices long after the tooling around it aged.

Two things to know before you trust it. The loop count and the row count are separate numbers that you keep in sync by hand, so a macro set to 200 passes against a 180-row file will run 20 passes on nothing. And a search term containing a space, an ampersand or a plus sign goes into the URL as typed, which is a broken request rather than an error message. Encode the column in the input file, not in the macro.

Where the macro stops

Content that arrives after the page does

TAG acts on the DOM as it is at that instant. If the table arrives by XHR half a second later, the command fires into an empty page and the extraction silently produces nothing. WAIT SECONDS=n is the only lever the language really gives you, and it is a guess dressed as a fix: too short and you lose rows, too long and you pay the cost on every page.

Modern tools wait for a condition instead of a duration, which is both faster and more reliable. Our guide to scraping dynamic content covers the general approach. Before reaching for any of it, open the network tab and look for the request that populates the table. If the page fetches JSON, scraping the API directly removes the browser, the wait and the parsing in one move.

CAPTCHAs

iMacros cannot solve them, and the old tricks are worth understanding precisely because they still circulate.

Early macros tried to beat the checkbox reCAPTCHA by clicking the box and then brute-forcing the image grid, selecting tiles at random and resubmitting until something worked. The arithmetic was never in your favour. Two correct tiles out of nine is one blind guess in 36. Four correct out of sixteen is one in 1,820. Add a few seconds per attempt and a challenge that reshuffles, and the expected time to a lucky hit exceeds the time to do the work by hand.

If a target throws a challenge, there are two realistic paths, and neither runs inside a macro. The first is a solving service wired into code that can put the returned token back into the page. Costs are public. 2Captcha's pricing page on 10 August 2026 lists reCAPTCHA v2 at $1 to $2.99 per 1,000 solves, reCAPTCHA v3 at $1.45 to $2.99, Cloudflare Turnstile at $1.45, and a plain image captcha at $0.50 to $1. Our CAPTCHA solving walkthrough shows the token round trip in full. The second path is cheaper and usually better: do not trigger the challenge. Sane request rates, a real session and rotating proxies keep most targets from ever asking.

One tab, one page at a time

This is the wall nobody mentions in the tutorials, and it is the one that actually decides whether you outgrow the tool.

A macro replays in a visible browser tab on a machine somebody owns. The loop is sequential by construction. At 2.5 seconds per page, 10,000 pages is just under seven hours during which that machine cannot sleep, cannot lock in a way that suspends rendering, and cannot be used for much else. Nothing in the macro language shortens that, because the only lever that would is running pages in parallel, and there is no syntax for it.

Code-based tools do not make each page faster. They let you run sixteen at once and put the whole thing on a server that has no screen. That is the entire difference, and it is worth an order of magnitude.

Recording did not die with iMacros

If what you liked was record-and-replay rather than iMacros specifically, the technique is in better shape now than it was in 2015. Each of these was rechecked on 10 August 2026.

Chrome DevTools Recorder is built into the browser you already have, with no install and no vendor. It has shipped since Chrome 97 and lives in its own DevTools panel. It records clicks, form input, navigation and scrolling, replays the flow with network throttling such as Slow 3G, and steps through with breakpoints when a step misbehaves. The export list is the useful part: JSON, a @puppeteer/replay script, a Puppeteer script, Puppeteer for Firefox, or Puppeteer with an embedded Lighthouse run. Import works from JSON only. One documented gap is worth knowing before you record a menu-driven flow: the Recorder does not capture hover events automatically, so you add those by hand afterwards.

That export is the migration path old iMacros users never had. Record by pointing and clicking, export as code, then edit the code when the site changes.

Playwright codegen is the same idea from the other end. npx playwright codegen demo.playwright.dev/todomvc opens a browser and writes the script as you click, choosing locators by role, text and test id rather than by DOM position. It records assertions for visibility, text and value, so a recorded flow can also check that the data arrived. --save-storage saves cookies, localStorage and IndexedDB at the end of a session, which is how you record a login once and reuse it in every later run. The documentation covers emitting the same recording as Python, Java or .NET.

Ui.Vision is the closest thing iMacros has to a successor, and the only one that says so out loud. Its Firefox listing was updated on 10 August 2026, the same day this was written, and both stores serve version 10.0.111. Source is on GitHub under AGPL-3.0, where the newest tagged release is 9.6.0 from 15 May 2026, so the shipped build runs ahead of the tags. The free tier is "Free for personal and commercial use" with unlimited web and desktop automation; PRO is US$299.00/Year, Enterprise for five users US$999+/Year, and the replay-only Enterprise Player US$1499.00. Everything runs locally rather than in a vendor cloud, which is the property that made iMacros usable behind a corporate firewall in the first place.

Web Scraper keeps the point-and-click habit and moves the running to a cloud. The extension is free and currently at 1.111.13; the hosted plans start at $50/month billed annually for 5,000 URL credits, $100 for 20,000, and from $200 for the unlimited tier, with residential proxies as a $2.50/GB add-on. We compare it against the rest of the category in best web scraper Chrome extensions.

The same job in Playwright, line by line

Porting a macro is mostly mechanical, because every iMacros command maps to something with an obvious name.

The paginated table macro from earlier, rewritten:

import csv
from playwright.sync_api import sync_playwright

def scrape(pages=20, out_path="results.csv"):
    with sync_playwright() as p, open(out_path, "w", newline="", encoding="utf-8") as fh:
        writer = csv.writer(fh)
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        for n in range(1, pages + 1):
            page.goto(f"https://example.com/products?page={n}", wait_until="domcontentloaded")
            rows = page.locator("table.data-table tbody tr")
            rows.first.wait_for(timeout=15_000)
            count = rows.count()
            if count == 0:
                break
            for i in range(count):
                writer.writerow(rows.nth(i).locator("td").all_inner_texts())
        browser.close()

scrape()

Written against Playwright for Python 1.62.0, published to PyPI on 31 July 2026. Twenty lines against seven, which is the honest price of the swap. What you buy for the extra thirteen: it runs headless on a server, it waits for the row instead of sleeping for a second, and it stops when a page comes back empty instead of appending garbage. It is also a file you can put under version control and run from cron.

The !DATASOURCE pattern converts just as directly. Read the CSV with csv.DictReader, loop over the rows, and use urllib.parse.quote on the search term, which removes the encoding trap the macro version quietly has.

When to stop recording

Recording is a fine on-ramp and a poor destination. Move to code when you need scale, unattended runs, or a site that fights back. The versions below were read from each project's own release channel on 10 August 2026:

• Playwright 1.62.1, released 30 July 2026. Auto-waiting, network interception and browser contexts that isolate sessions. The codegen recorder means you can start by pointing and clicking and still end up with a script.
• Puppeteer 25.5.0, released 4 August 2026, plus @puppeteer/replay 4.0.2 from May 2026, which runs a DevTools Recorder JSON file straight from the command line.
• Selenium, stable at 4.46.0 as of 11 July 2026 on the project's download page, with 4.47.0 landing on PyPI on the day this was written. If Java is your language, our WebDriver tips cover the parts people get wrong. Note the contrast inside the same project: Selenium IDE's command-line runner has not been published since 4.0.13 in November 2024, while the core bindings ship monthly. Record-and-replay is nobody's priority anywhere.
• WebdriverIO 9.30.1, released 3 August 2026, if you want the test-runner ergonomics without leaving the browser stack.
• HTTP plus a parser stays the fastest route for server-rendered pages. No browser process and no rendering, which is the whole reason it wins.

There is a third option that is neither a macro nor a codebase. When the requirement is the dataset rather than the tooling, a managed web scraping service or data as a service delivers rows on a schedule, and nobody on your side maintains selectors or a proxy pool the week the target redesigns.

Wrapping up

The iMacros macro language is still a good description of a small extraction job: URL GOTO to move, TAG ... EXTRACT to take a value, SAVEAS to write it, {{!LOOP}} to repeat, !DATASOURCE to feed it inputs. Read an old macro and you will understand it in a minute, which is more than most automation formats manage.

What has changed is where you can run it. As of 10 August 2026 the Chrome update service serves no iMacros package, addons.mozilla.org lists no iMacros add-on, and the documentation wiki that every tutorial links to no longer resolves. The paid desktop edition with its own Chromium is what the vendor still sells, and it publishes neither a changelog nor a price. If you are starting today, record in the DevTools Recorder or Playwright codegen and export code. If you have working macros, Ui.Vision is the migration target that advertises conversion help. And if the macro you are about to write would run for seven hours in a tab nobody can touch, it was never the right tool for that job.