📖Flow steps reference

Where every run begins. A Flow has exactly one, it cannot be deleted, and nothing can be wired into it.

The Flow's Asked for at Run inputs are edited here as well as in the Flow's own settings.

Stops the run and closes the browser, unless keep open is ticked in the toolbar. It has no outgoing wire.

A Flow that simply runs out of wires also finishes, but with a warning — add an End to be explicit.

A pause. A random range beats a fixed one: a fixed cadence is periodic, and periodic is machine.

A random wait is skewed towards the shorter end of the range.

Opens a loop. Pair it with a Loop end step carrying the same name — the pair is the loop.

A name with no matching Loop end fails the run: loop "{id}" has no matching Loop end node.

Closes the loop of the same name. Its next wire is where the run goes once the loop is finished.

Runs another Flow from your library here, on this same browser, then carries on. That Flow's End returns to this one. Edit the shared Flow once and every Flow that runs it gets the change.

Flows can be nested eight deep. Deeper than that is a Flow to flatten, not to run.

A JavaScript condition, evaluated in the page. Flow variables are available as vars.name, and so is the DOM. Two wires: then and else (the else wire is drawn in a different colour).

For example vars.count < 5 or document.querySelector(".cart") !== null.

Rolls the dice: the yes wire that often, the no wire the rest of the time — so a Flow likes some posts and not others, the way a person does. The templates use it for "randomly like".

Writes a run variable.

JavaScript, run in the page — the same context devtools gives you. It cannot reach Node, the filesystem or your profiles, on purpose: Flows are shareable.

Async is fine. Flow variables are in vars. return a value to store it.

Writes a line into the run log. ${variables} are interpolated.

A note for whoever opens this Flow next. Does nothing at run time.

Navigates the current tab and waits for the page to become readable.

Only http:, https:, about: and file: addresses are accepted; anything else fails with "{url}" is not a URL this can open.

Opens another tab and makes it the one the Flow is driving.

Points the Flow at a different open tab.

Closes the tab the Flow is on and falls back to whichever is left. No settings.

On the last tab it refuses: this is the last tab — closing it would end the session, use End instead.

One step back in this tab's history. No settings.

One step forward in this tab's history. No settings.

Reloads the current page. No settings.

Polls the page's readyState rather than waiting on the load event — a page with one hung third-party beacon never fires load, and a Flow must not hang on it.

Polls until the element resolves. Because it resolves by features, it waits out a layout change rather than timing out on one.

This is the right way to handle a slow page — better than a longer Wait.

Captures the viewport into this run's folder.

The cookie warm-up robot, as a step: wanders real sites for a while — read, scroll, click deeper, move on — so the profile's jar and history look lived-in before the Flow does anything that matters.

It stops early after two bot checks. See Warm up new profiles.

A real trusted click: the pointer travels there first, settles, then presses. Not element.click().

If the click opens a popup window — "Continue with Google", for instance — the Flow follows it automatically and logs a new window opened — following it.

Moves the pointer onto the element and leaves it there, for menus that open on hover.

Types at this profile's own persistent cadence, with its own typo rate. Pasting is scored on signup and checkout forms; this is not a paste.

This is the only step that will type a saved password or a 2FA code, and only on that account's own site. See Saved logins and 2FA codes.

One trusted key press at whatever has focus.

Real wheel events with reading pauses and the occasional look back up — the warm-up robot's scroll, not scrollTo().

Chooses an option in a <select>, then fires the change event the page is listening for.

Hands a file to a file input without opening the operating system's picker.

A request made by the app, not the page — so no CORS, and none of the profile's cookies. The reply is stored, never executed.

The element's visible text, resolved by features so it survives the page being rebuilt around it.

One attribute — href, value, data-id — off the resolved element.

The page's clipboard, not the app's. Permission is granted to the current site for the length of the call.

Now, in the shape you want to use it in.

A number in a range, or one of a list of choices.

Turns lines or a CSV into a list variable, which a Loop N step can then drive.

Appends what a run found to a file on this computer — a list as CSV rows, an object as a JSON line, text as lines. The path is a plain visible setting, so a Flow somebody sent you cannot hide where it writes.

Asks your AI model for a short piece of text — a comment, a reply, a caption — from a prompt. On LoginDeck AI it costs one AI action per call; your own key or CLI is not metered.

See LoginDeck AI actions.

The name, OS, tags, folder, timezone, engine and proxy (without its password) of the identity this run is driving.

The stored object holds id, name, os, tags, folder, timezone, proxy, engine, patched and headless.

Where this session actually comes out. It uses the answer the launch already resolved, and asks again only if there is none.

The stored object holds ip, country, countryCode, region, city, isp and timezone. This is what the Proxy check: exit IP & location template is built from — see Start from a template.