Skip to main content
In Agent mode, tasks are built from a sequence of actions. These actions are executed sequentially by the browser.

Navigation & Interaction

Click, type, scroll, hover, press keys, and navigate between pages.

Logic & Flow Control

Conditionals, loops, repeats, and error handling.

Data & Variables

Set variables, parse CSV, merge data, and extract content.

Advanced Actions

JavaScript execution, HTTP requests, CAPTCHA solving, and screenshots.

​
Basic Actions

Interacts with a button, link, or other clickable item.
  • Selector: The CSS selector of the target element (e.g., #btn, .link).
  • Click Type: single (default), double, or right.
  • Wait: Optional delay (in seconds) after clicking.
Ensures a checkbox or radio control is selected. This is idempotent: an already-selected control is left unchanged.
  • Selector: The checkbox or radio control to select.
Ensures a checkbox is cleared. The selector must target a compatible checkbox control.
  • Selector: The checkbox to clear.
Drags the element matched by Selector onto the element matched by Target Selector. Choose each selector independently, including in headful selector picking.
  • Selector: The draggable source element.
  • Target Selector: The required drop target element.
Selects an option in a native HTML <select> control.
  • Selector: The native select element.
  • Value: The option value to choose.
Reloads the current page and waits for the refreshed document to load.
Types text into an input field. Use this for filling out forms or search bars.
  • Selector: The target input (e.g., input[name="q"]).
  • Value: The text to type. Can include {$variables}.
  • Mode: Replace (clears existing text) or Append (adds to end).
Pauses execution for a fixed duration. Use this when you need a simple delay, though Wait for Element is often more reliable.
  • Value: Duration in seconds (e.g., 2.5).
Waits until a specific element appears in the DOM. Use this to ensure the page has loaded the content you need before proceeding.
  • Selector: The element to wait for.
  • Value: Timeout in seconds (default: 30).
Simulates a keyboard key press. Use this for navigation keys like Enter, Tab, or Escape.
  • Key: The key name (e.g., Enter, Tab, Escape, ArrowDown).
  • Selector: (Optional) Focus this element before pressing.
Scrolls the page or a specific element. Use this to reveal content that loads on scroll (lazy loading).
  • Selector: (Optional) The element to scroll. If empty, scrolls the window.
  • Value: Pixels to scroll (e.g., 500) or specific commands (bottom, top).
Moves the mouse cursor over an element. Use this to trigger dropdown menus or tooltips.
  • Selector: The target element.

​
Logic & Flow Control

Conditional execution block. Use this to handle dynamic situations, like closing a popup only if it appears.
  • Condition: A JavaScript expression (e.g., exists('.error')).
  • Selector: (Structured mode) Target element.
  • Operator: equals, contains, exists, etc.
Repeats a block of actions while a condition is true. Use this for pagination or waiting for a specific state change.
  • Condition: Same as if.
  • Value: (Optional) Max iterations to prevent infinite loops.
Iterates over a list of elements. Use this to scrape lists of items, like search results or product cards.
  • Selector: The elements to iterate (e.g., .product-item).
  • Var Name: Variable to store the current element index/data.
Repeats a block N times. Use this when you know exactly how many times an action needs to happen.
  • Value: Number of repetitions.

​
Data & Variables

Updates a runtime variable. Use this to store calculations or flags for later use.
  • Var Name: The variable to update (e.g., counter).
  • Value: The new value (can be a JS expression).
Parses CSV formatted text into rows (an array of objects). Use this to extract data out of comma separated text for further processing.
  • Value: The CSV text to parse. If left blank, it will attempt to use the output of the previous block (block.output).
Merges multiple arrays, objects, or primitive values into a single output. Use this when you have collected data from different steps and need to combine them into one payload.
  • Value: Comma-separated list of values or variables to merge (e.g., items, extraItems, {$block.output}).
  • Target Variable: (Optional) The name of a new or existing variable to store the merged result (e.g., allItems).
Extracts the text content of the current page or a specific element. Use this to capture visible text without writing a custom JavaScript block — for example, grabbing an article body, a table’s contents, or the entire page text for downstream processing.
  • Selector: (Optional) A CSS selector targeting the element to read. If empty, the full page text is returned.
  • Store In Variable: (Optional) A variable name to store the extracted text for use in later blocks.
The action returns the innerText of the matched element (or document.body when no selector is provided). If the selector matches no element, the result is null.Example — store the main article text in a variable:After this block runs, {$articleText} contains the visible text of the .article-body element.

​
Advanced Actions

Executes custom JavaScript in the browser context. Use this for complex logic, data extraction, or interactions not supported by other blocks.
  • Value: The JS code (e.g., return document.title;).
  • Output: The return value is stored in block.output for subsequent steps.
Takes a screenshot at the current state. Use this for debugging or keeping records of the task execution.
  • Value: (Optional) Filename suffix.
  • Selector: (Optional) Capture only this element.
Immediately stops the task execution. Use this to end the task early based on a condition (e.g., login success).
  • Value: Exit status (e.g., success, failure).
Waits for file downloads to complete. Use this after clicking a download button to ensure the transfer finishes before the task continues.
  • Value: Timeout in seconds.
Completed downloads are persisted in the task’s selected Cabinet, introduced in v0.17.
Attaches the newest unuploaded item from a Cabinet to the current page. Use it for download-then-upload workflows without moving files outside Figranium.
  • Selector: Target file input, file chooser trigger, or compatible drop target.
  • Cabinet ID: (Optional) Cabinet to read from. If omitted, the task’s Cabinet is used, then the default Cabinet.
  • Mark As Uploaded: (Optional) Mark the item uploaded immediately after attaching it.
Upload supports ordinary files, ZIP archives, compatible folders, native file inputs, file choosers, and drop targets.
Marks all Cabinet items attached during the current execution as uploaded.Use this after the surrounding form submission or upload flow succeeds when you want consumption to happen later than the attachment itself.
Defines a block of actions to run if an error occurs in the main flow. Use this to implement retry logic or graceful failures (try/catch).
Makes a server-side HTTP request to any URL. Use this to call external APIs, send webhook notifications, or fetch data from REST endpoints — without leaving the task flow.
  • Method: GET, POST, PUT, PATCH, or DELETE.
  • URL: The target endpoint. Supports {$variables} for dynamic URLs.
  • Headers: (Optional) A JSON object of request headers (e.g., {"Authorization": "Bearer {$token}"}).
  • Body: (Optional, shown for POST/PUT/PATCH/DELETE) The request payload, typically JSON.
  • Store Response In Variable: (Optional) A variable name to store the parsed response for use in later blocks.
The request is executed on the server, not in the browser context. If the response body is valid JSON it is parsed automatically; otherwise it is stored as a plain string. Non-2xx responses throw an error that you can catch with an On Error block.
Requests to private or internal network addresses are blocked unless the ALLOW_PRIVATE_NETWORKS environment variable is enabled. See Security for details.
Example — fetch an API and store the result:After this block runs, {$apiResponse} contains the parsed JSON response.
Triggers another task to run from within the current task. Use this to create modular workflows by chaining tasks together.
  • Task: The ID of the task to run.
Detects a CAPTCHA challenge on the current page and solves it through a configured YesCaptcha/AntiCaptcha-compatible endpoint (tried first when set) or the built-in active-browser local solver, then injects the token back into the page so the site’s own callback fires. Use this when a specific step reaches a challenge you already know about — for example, right after submitting a login form.Supported challenge types: reCAPTCHA v2, reCAPTCHA v3, hCaptcha, and Cloudflare Turnstile.
  • Captcha Type: (Optional) One of recaptcha_v2, recaptcha_v3, hcaptcha, or turnstile. If empty, the type is auto-detected from the page.
  • Selector: (Optional) A CSS selector scoping the search to a specific container (for example, the widget’s iframe wrapper). If empty, the whole page is scanned.
  • Store In Variable: (Optional) A variable name to store solve metadata ({ success, challenge, duration, provider, model?, device?, attempts }).
  • Timeout: (Optional) Terminal deadline in milliseconds. Defaults to 120000. Image challenges usually take over a minute. Provider errors are returned immediately rather than being reported as timeouts.
The block runs in Agent mode only. Local image solving requires at least 2 GiB effective cgroup memory since the model runs in-process; lower-memory hosts can still use a configured remote endpoint. Set SKIP_LOCAL_CAPTCHA_MODEL=true to disable the local route entirely.Example — solve a reCAPTCHA v2 widget and store the result:For tasks that hit CAPTCHAs at unpredictable points, you can turn on the task-level Auto-Solve Captchas setting instead of scattering Solve Captcha blocks through the flow. It runs the same detection pass after the initial task navigation and after every Navigate, Click, and Type, and no-ops when no challenge is present. See CAPTCHA Solving for the full setup, environment variables, and the auto-solve toggle.
Pauses the task until a CAPTCHA control on the page is initialized, visible, enabled, pointer-receivable, and stable. The block does not click or solve the challenge. Use it to gate later steps on the widget being ready — for example, before handing the page to your own solving logic, or to confirm that a challenge rendered at all.Supported challenge types: reCAPTCHA v2, reCAPTCHA v3, hCaptcha, and Cloudflare Turnstile.
  • Captcha Type: (Optional) One of recaptcha_v2, recaptcha_v3, hcaptcha, or turnstile. If empty, the block waits for the first ready challenge of any supported type.
  • Container Selector: (Optional) A CSS selector scoping the search to a specific container. If empty, the whole page is scanned.
  • Timeout: (Optional) Deadline in milliseconds. Defaults to 120000. If no ready challenge appears before the deadline, the block errors with wait_captcha: no ready CAPTCHA found within <timeout>ms, which an On Error block can catch.
  • Store Result In Variable: (Optional) A variable name to store { ready, challenge, duration, siteKey? }.
Example — wait for a Turnstile widget scoped to its container:See CAPTCHA Solving for the readiness checks and return value details.
Performs no operation and moves to the next block. Use this as a placeholder while drafting a task, or as the body of an If or On Error branch when you explicitly want the branch to fall through without side effects.The block takes no configuration. It logs Do nothing and completes successfully. The aliases noop and pass behave the same way.Example — placeholder inside an if branch:

Selectors

Learn how to target elements with CSS, XPath, and Playwright extensions.

Variables

Define dynamic parameters and reuse values across blocks.

Control Flow

Build conditionals, loops, and error handling into your tasks.

Data Extraction

Capture and structure page data for export and downstream use.