Recording a Scenario

If you don't have a JMeter test plan yet, the recorder makes one by watching you use your application. You click through a flow in a real browser — log in, search, check out — and it writes a .jmx you can run as a load test.

Install

npm install -g @cloudbeat/atlas-recorder

This downloads a private browser build (a few hundred MB) used for capture. It won't touch the browsers you already have. Requires Node.js 18 or newer.

It's a separate package from the CLI because CI machines run tests but never record them.

Record

atlas-rec record https://example.com -o checkout.jmx -n "Checkout"

Or through the CLI, which can upload the result straight into a project:

atlas record https://example.com -o checkout.jmx --upload -p SHOP

A browser window opens with a small control panel in the corner. Click through your flow, then press Stop.

Your recording is saved when you press Stop, when you close the window, and on Ctrl+C — closing the window by mistake won't lose it.

What you get

Each thing you do — a click, a form submit, a page change — becomes a labelled transaction, with the requests it triggered grouped underneath. A report then tells you "Checkout took 3.2s" rather than just listing URLs.

While recording you can:

• rename a transaction so the report reads in your language, not the app's URLs
• ➕ New to start a new transaction before you click, when one page holds two steps worth measuring separately
• expand a transaction and exclude or delete individual requests
• ⏸ Pause while you set something up you don't want recorded

What's kept, and what isn't

Kept: the requests your application makes — pages, API calls, form posts.

Skipped: images, stylesheets, fonts and known analytics traffic. These inflate a load test without telling you anything about your application. Include one from the control panel if you need it.

Dynamic values are handled

If a request sends something it was given earlier — a CSRF token, a session ID, an item ID from a search result — the recorder finds where that value came from and pulls it out of the live response at run time instead of replaying the recorded one. Without this, a recorded plan usually fails on the second run, when the token has changed.

Each of these gets a check attached, so if the value ever stops coming back the sample fails loudly rather than quietly posting a stale token.

Adding to an existing plan

Point -o at a plan that already exists and the new recording is added to it as another thread group, leaving what's there untouched. A .bak copy is written first.

atlas-rec record https://example.com -o suite.jmx -n "Checkout"
atlas-rec record https://example.com -o suite.jmx -n "Search"

Recording behind a login

Reuse a signed-in session — saved when you stop, reloaded next time:

atlas-rec record https://app.example.com -o app.jmx --profile ./session.json

Bring cookies from your own browser — export them and pass --cookies:

atlas-rec record https://app.example.com/home -o app.jmx --cookies ./cookies.json

Options

Option	Meaning
-o, --out <file>	Where to write. An existing plan is added to; otherwise created
-n, --name <name>	Name for the scenario
-t, --threads <n>	Number of users — only when creating a new plan
-l, --loops <n>	Iterations per user — only when creating a new plan
--profile <file>	Save and reuse a signed-in session
--cookies <file>	Start already signed in, using exported cookies
--correlations <file>	Pin named parameters to a value of your choosing
--no-correlate	Replay recorded values as-is
--no-timestamps	Keep recorded timestamps instead of using the current time

Check the plan before running it at scale

The recorder captures a single pass through your app. Anything that only appears sometimes — a cookie banner, an A/B variant, a retry — is recorded only if it happened while you clicked.

A redirect is recorded twice

When a step redirects, the redirect is followed and the destination is recorded on its own, so that step can hit the destination twice per iteration. Delete the duplicate from the control panel, or from the plan afterwards, if it would skew your numbers.

Think-time pauses are recorded but switched off, so the plan runs flat out until you decide otherwise. Enable the Settings - Sleeps block in the plan and set the durations you want.

Driven by an agent, or a script

A recording does not have to be clicked by a person. The same session can be controlled command by command — snapshot to see the page, click, fill, tx new to name the step that follows — which is how an AI assistant records a flow for you, and how a script can automate one.

The browser stays visible throughout and your own clicks are recorded too, so you can take over for a login and hand it back.

atlas-rec start https://shop.example.com -o flow.jmx -n "Checkout"
atlas-rec snapshot
atlas-rec tx new "Search"
atlas-rec click --role button --name "Search"
atlas-rec stop

See Your Own Integration for the full set, and Atlas for AI Agents to let an assistant do it.