Record a Test Beta

Do the test once. Get steps and scripts.

Hawzu Recorder is a Chrome extension. Run through a test in a browser window, and the test case keeps what you did — as readable manual steps, and as Playwright (TypeScript) and pytest + Selenium (Python) scripts that your own CI runs.

Start free Add to Chrome

One recording

What you did, three ways

A five-step sign-in, recorded once. The same recording gives the steps a tester follows and the code an engineer commits — and it gives the same files every time.

Recorded

navigate app.example.com/login
fill Email · alice@example.com
fill Password · HAWZU_PASSWORD
click Sign in
assert Welcome back, Alice · is visible

Steps for whoever runs it by hand

Open https://app.example.com/login
Enter "alice@example.com" in the "Email" field
Enter the value of HAWZU_PASSWORD in the "Password" field
Click the "Sign in" button
The "Welcome back, Alice" heading is visible

Playwright (TypeScript) HAW-101-recorded-flow.spec.ts

test("HAW-101 Recorded flow", async ({ page }) => {  // 3. Enter the value of HAWZU_PASSWORD in the "Password" field  await page.getByLabel("Password", { exact: true }).fill(secret("HAWZU_PASSWORD"));  // 4. Click the "Sign in" button  await page.getByRole("button", { name: "Sign in", exact: true }).click();  // 5. The "Welcome back, Alice" heading is visible  await expect(page.getByRole("heading", { name: "Welcome back, Alice", exact: true })).toBeVisible();

pytest + Selenium (Python) test_haw_101_recorded_flow.py

def test_haw_101_recorded_flow(driver, record_property):    record_property("testcase_code", "HAW-101")    # 3. Enter the value of HAWZU_PASSWORD in the "Password" field    el = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "#password")))    el.clear()    el.send_keys(os.environ["HAWZU_PASSWORD"])    # 4. Click the "Sign in" button    el = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "form > button[type=submit]")))    el.click()

carries the test case code reads a secret from the environment

While you record

Do the test the way you always do

The extension opens its own Chrome window, with its controls in Chrome's side panel — beside the page, not on top of it. Everything you do there appears in Hawzu as it happens. The panel is for what a click cannot say.

Five checks, each comparing exactly. Choose one, then the element to check.

Recorded as you go

Going to an address, reloading, back and forward
Clicks — right, middle and double too
Typing, saved once with the final value
Select lists, checkboxes
Enter, Escape, arrows, function keys and shortcuts
File uploads, by file name
Hover, when you ask for it

The password stays on the page

Type into a field the recorder recognises as a password, a one-time code or card details, or one you marked Secret, and only a variable name is saved. The step says so in plain words, and both scripts read the value from that environment variable when your CI runs them.

Recognising a field is a best effort, and everything else you type is saved as typed. When in doubt, press Secret before you type.

On the page

Password ••••••••••••

In the recording HAWZU_PASSWORD

Enter the value of HAWZU_PASSWORD in the "Password" field

Locators

Checked while you record, open to inspect after

Locators are checked against the live page as you click, and the alternatives are kept. The Locators tab shows which one each script uses, what the rest matched, and the Object Repository object the step belongs to.

4 Click the "Sign in" button

getByRole("button", { name: "Sign in", exact: true }) unique
form > button[type=submit] unique
button[type=submit] not unique
#login-submit no match

// HAWZU_TODO: locate the cross-origin frame https://consent.vendor.example/banner

Where a person is needed, the script says so in a line you can search for, rather than guessing.

Object Repository

A page changed? Fix the locator once.

Every element a recording acts on becomes an object in the project, shared by the test cases that use it. When its locator breaks, fix the object, and every one of those test cases gets the new locator the next time its script is opened in Hawzu.

OBJ-12 Sign in button Checked

v3 · used by 4 test cases

Fix locator

Pick again in the browser Checked
Use a recorded step's locator Checked
Edit by hand Hand-edited

Saving makes OBJ-12 v4, marked Checked

Now page.getByRole("button", { name: "Sign in", exact: true }) After saving page.getByTestId("sign-in")

This changes the scripts of 4 test cases (4 recordings, 5 steps).

Suggested, then confirmed When a new step looks like an element the project already has — the same test id, or the same role and name, on the same page — Hawzu suggests it. A person confirms, or keeps them apart.
A preview before every change What each script prints now and after saving, and every test case whose script changes.
Versions you can go back to Each fix is a new version of the object, and an earlier one can be restored the same way.
Fragile locators flagged A locator that picks by position, uses an absolute XPath or matches text that changes is flagged before it breaks.
Linked to CI failures When an imported failure names a locator a script printed, the failure is linked to that object.

A file already in your repository keeps the old locator until you download it again. Workspace owners, workspace managers and project managers change objects — see the Object Repository documentation.

Where it runs

Your CI runs it. The result comes home.

Hawzu does not run the scripts. Each one carries its test case's code, so when the report is imported the result lands on the right test case without a mapping file.

Record Do the test once in Chrome.
Commit Copy or download the script into your repository.
Your CI runs it With Playwright or pytest, like any other test.
Import the report The JUnit report comes back into Hawzu.
HAW-101 Each result lands on the test case whose code it carries.

Imports work with Jenkins, GitHub Actions and GitLab CI — see CI/CD Automation. What to set before the first run is in the documentation.

Use as manual steps

Or skip writing the steps

One button writes the recording into the test case as its manual steps. Replace what is there, or add after it — Hawzu tells you exactly what will change before it does. It works while you create a test case too, in the Multiple and Single step modes.

Multiple One step per action, with its expected results
Single A single step listing every action

The honest part

What it does not do

Record a Test is in beta. This is where it stops for now — worth reading before your first recording rather than during it.

Desktop Chrome only

Recording needs Chrome 120 or later with the Hawzu Recorder extension. Firefox, Safari and mobile browsers are not supported.

Not recorded

Scrolling, dragging and touch. A new tab or popup is not followed either — the step that opened it is marked for review.

Frames and shadow roots

Inside a cross-origin iframe, the script is left with a HAWZU_TODO where the frame must be located. Inside a closed shadow root, the locator points at its host.

File names, not files

An upload records the names of the files you chose. Putting those files next to the test is a HAWZU_TODO for you.

Exact checks, trim-only steps

Assertions compare exactly, whole text and whole URL. Steps can be removed from a recording but not reworded. A broken locator is fixed in the Object Repository, without recording again.

Two frameworks, fixed sizes

Playwright (TypeScript) and pytest + Selenium (Python), for test cases in the Multiple or Single step mode, not Gherkin. Up to 20 recordings per test case, 500 steps and 1.5 MB each. Free saves 30 recordings a month; Growth has no monthly limit.

Permissions and troubleshooting are in the documentation.

Questions

The ones worth asking first

Does Hawzu run the recorded tests?

No. The scripts are ordinary files you keep in your repository, and your own CI runs them with Playwright or pytest. When you import the run's report, the test case code each script carries puts every result on the right test case.

Is Record a Test codeless automation?

No. What you get is code — TypeScript and Python you can read, change, review and commit. Recording writes the first version, so nobody starts an automated test from a blank file.

Does the recorder save my passwords?

Fields it recognises as a password, a one-time code or card details, and any field you mark Secret, are saved only as a variable name such as HAWZU_PASSWORD, and the scripts read the value from that environment variable. Recognition is a best effort and everything else you type is saved as typed, so mark a sensitive field Secret before typing into it.

How reliable are the recorded locators?

They are checked against the live page while you record, and the alternatives found are kept alongside them. The Locators tab shows which one each script uses, what else was tried, what matched and what was refused. A page that changes later can still break a script. When one does, fix that element's locator in the Object Repository, and every test case that uses it gets the fix.

What happens to the scripts if I rename the test case?

Inside Hawzu they follow it. Scripts are rebuilt from the recording every time you open them, with the test case's current code and title, and the current locator of each Object Repository object the recording uses. A file you already downloaded does not change.

What happens when a page changes and a locator breaks?

Fix it once. Every element a saved recording acts on is an object in the project's Object Repository, shared by the test cases that use it. Pick the element again in Chrome, use the locator from a step recorded on the changed page, or edit it by hand, and read the preview of what each script will print. From then on those test cases' scripts use the new locator when opened in Hawzu. Files already in your repository keep the old one until you download them again.

Which browsers and frameworks does it support?

You record in desktop Chrome 120 or later. The scripts are Playwright (TypeScript) and pytest + Selenium (Python); the Python file uses the driver fixture your own setup provides.

Who can record a test?

Anyone who can edit test cases, on an existing test case, and anyone who can create them, from the create form. Anyone who can view test cases can read recordings, their steps and their scripts. Recording works with test cases in the Multiple or Single step mode, not Gherkin. On the Free plan a workspace saves up to 30 recordings a month, deleted ones included; Growth has no monthly limit.

Elsewhere in Hawzu