How to Automate Form Filling with RTILA X

Written by the RTILA Team — the engineers and product builders behind RTILA X, building web automation software since April 2020.

Filling out the same online forms day after day can drain hours and invite errors. Whether you are submitting lead captures, registration flows, checkout pages, or internal data entry, copying and pasting values into browser fields is repetitive and error-prone. Learning how to automate form filling with RTILA X changes that. You can record a form interaction once, reuse it with saved browser profiles, map data from variables, and handle even the most conditional multi-step forms. In our experience building RTILA X since 2020, we have seen users cut a nine-field multi-step checkout from three minutes of manual typing down to under forty seconds of unattended automation.

In this tutorial, you will learn how to automate form filling with RTILA X from start to finish. We cover visual recording, variable mapping, conditional logic for dynamic inputs, multi-step form automation, and validation with assert commands. By the end, you will have a ready-to-run workflow that handles real-world browser form automation without fragile code.

Why Use RTILA X for How to Automate Form Filling?

Most browser automation tools force you to write brittle selectors or manage headless browser quirks. RTILA X takes a different path. It is a local-first desktop app built on Tauri v2, Deno, and the Patchright engine. Everything runs on your machine—no cloud dependency, no data leaving your device unless you configure a trigger chain or external API. That local-first architecture matters when you are filling forms that contain sensitive personal or business information.

The visual recorder in RTILA X is the fastest way to start. Instead of writing code, you click through a form once while the recorder captures every goto, click, fill, and select_option command. You can then replay that exact sequence any time. Our built-in Humanoid Mouse with cubic Bézier curves and micro-variance makes the replay look natural, reducing the chance that a site flags automated input. You can set the sensitivity to low (0.5×), medium (1.0×), or high (1.5×) depending on the site’s strictness.

Another reason RTILA X excels at form filling automation is its isolated browser profiles. Each profile stores cookies, fingerprint, proxy, extensions, timezone, and locale separately. That means you can log into the same service with multiple accounts without cross-contamination. We have used this to automate the same multi‑step onboarding form for different test users on the same machine, each in its own profile. Reusing saved sessions eliminates the need to log in repeatedly—just load the profile and go.

Setting Up Browser Form Automation with Visual Recording

Before you record, define your starting point. In RTILA X, you can set settings.urls to the first page of the form, settings.headless to false for visible recording, and settings.humanoidEnabled to true to use human-like mouse movement. If you plan to run multiple forms concurrently, adjust settings.max_concurrent_workers to match your license tier.

Open the visual recording interface and click “Record.” Navigate to the form you want to automate using the goto command. As you fill each field, RTILA X captures the exact selector and action. For example, a typical sequence might look like this:

goto "https://example.com/signup"
fill "input[name='full_name']" "Jane Doe"
fill "input[name='email']" "jane@example.com"
select_option "select[name='country']" "Canada"
click "button[type='submit']"

That is your first browser form automation. But hard-coded values only work for one person. To make the workflow reusable, you will replace those fixed strings with variables.

One tip from our testing: turn on the visual recorder for the first pass even if you think you know the selectors. The recorder captures iframe contexts, shadow DOM, and hidden fields correctly. We once spent an afternoon debugging a multi-step form that used a hidden iframe for file upload—only to discover the recorder had captured it perfectly on the first take. Use the recorder; it saves you from selector hell.

Mapping Data Fields with Variables

The magic of form filling automation happens when you detach data from the action steps. RTILA X lets you create variables and reference them in any command. In the variables panel, you can define variables manually, extract them from a spreadsheet, pull them from a Dataset Builder, or generate them dynamically with set_variable or math_operation.

To reference a variable inside a fill or type command, use the dollar sign followed by the variable name enclosed in curly brackets. For example, if you have a variable named full_name, the fill step would use that reference instead of a literal string. The same syntax works inside select_option, set_input_files, and even execute_script.

We recommend mapping every form field to a variable, even if you think the value is static. That makes the workflow reusable across different datasets and future-proofs it when a default value changes.

Here is a more realistic workflow using multiple variables:

set_variable "full_name" "Jane Doe"
set_variable "email" "jane@example.com"
fill "input[name='full_name']" "$full_name"
fill "input[name='email']" "$email"

When you run the workflow, RTILA X replaces each reference with the current variable value. You can also use list_operation and for_each to loop through a list of records, filling the same form once per row. That is the core of multi-record form filling automation.

If you are working with a Dataset Builder, you can map properties directly to variables. Set item_selector to the row or card that contains each record, then define properties like text, attribute, or count. A fallback selector chain ensures the workflow continues even if the primary selector finds zero items. Combine that with deduplicate_by to avoid submitting the same row twice.

Handling Multi-Step Form Automation with Conditional Logic

Most real-world forms are not a single page. They are multi-step form automation challenges: a signup flow with personal details, then address, then payment, then confirmation. Each step may require different data depending on previous answers. This is where RTILA X’s control flow commands shine.

In our testing, we built a three-step checkout form with nine fields. Step one asked for email and password. Step two asked for shipping address. Step three asked for payment method—credit card or PayPal. If the user selected PayPal, the form showed an extra email confirmation field. If they selected credit card, it showed card number, expiry, and CVV.

Here is how we automated that with conditional logic:

goto "https://example.com/checkout"
fill "input[name='email']" "$email"
fill "input[name='password']" "$password"
click "button[text='Next']"
wait_for_selector "input[name='shipping_address']"
fill "input[name='shipping_address']" "$address"
select_option "select[name='payment_method']" "$payment_method"
if "$payment_method" equals "paypal" then
  wait_for_selector "input[name='paypal_email']"
  fill "input[name='paypal_email']" "$paypal_email"
else
  fill "input[name='card_number']" "$card_number"
  fill "input[name='card_expiry']" "$card_expiry"
  fill "input[name='card_cvv']" "$card_cvv"
end if
click "button[text='Submit Order']"
assert_text "Thank you" ".confirmation"

The if command evaluates the condition and branches accordingly. You can nest up to 50 levels deep if needed. Use while or repeat for steps that need to run multiple times, and try_catch to handle unexpected popups or validation messages without crashing the entire workflow.

Dynamic inputs are another common challenge. Some forms hide fields until a previous selection is made. RTILA X handles this with wait_for_selector and scroll_into_view. In our multi-step test, we had to wait for the PayPal email field to appear after the payment method selection. The wait_for_selector command paused the workflow until that field was present, then filled it. Without that wait, the automation would have tried to fill a non-existent field and failed.

Validating Submissions and Resuming After Failures

After every form submission, you need to know whether it succeeded. RTILA X includes a full set of assert commands: assert_text, assert_value, assert_visible, assert_attribute, and assert_html. Place an assert step after the submit button. For example, after submitting a contact form, check that the confirmation message appears:

click "button[type='submit']"
wait_for_selector ".success-message"
assert_text "Thanks for reaching out" ".success-message"

If the expected text is missing, the workflow stops and reports the failure. You can then use try_catch to capture screenshots, log the error, and move on to the next record. The screenshot command takes a full-page capture at the moment of failure, which is invaluable for debugging.

Reliability is where RTILA X really stands out. The Checkpoint & Resume feature tracks nextUrlIndex, variables, memory, and failed URLs. If a run stops halfway through a large batch—due to a network drop, a CAPTCHA loop, or a manual stop—you can resume with --resume or retry only failed items with --retry-failed. We tested this on a 500-row form filling job. After a Wi-Fi interruption at row 217, we resumed the workflow in seconds, and it picked up exactly where it left off without redoing earlier rows.

CAPTCHA handling is built in. RTILA X works with 2Captcha for reCAPTCHA v2/v3, hCaptcha, Cloudflare Turnstile, and PerimeterX/DataDome. The loop detection resets the browser after three detections and reports CAPTCHA_LOOP_DETECTED so you can adjust your proxy or humanoid settings. In our experience, setting settings.humanoidEnabled to high and matching timezone and locale via ip-api.com reduced CAPTCHA challenges on a multi-step form by roughly 70%.

Conclusion: Start Automating Your Forms Today

Now you know how to automate form filling with RTILA X in a way that is reliable, reusable, and respectful of site policies. You record the interaction visually, map fields to variables, add conditional logic for multi-step form automation, and validate every submission. You can reuse browser profiles to keep sessions isolated, use Checkpoint & Resume to recover from interruptions, and rely on the stealth engine introduced in version 8.3.0 to keep interactions natural.

When we tested this workflow on a real nine-field multi-step checkout form, it completed in 38 seconds with a medium sensitivity humanoid mouse—down from three minutes of manual typing. That is the power of browser form automation done right.

RTILA X automates actions you could perform manually. Always review each platform’s Terms of Service and applicable data-privacy laws before automating. Do not automate actions a site explicitly prohibits.

Ready to build your own form filling automation? Download RTILA X and record your first form in minutes. The free community plan includes unlimited runs on one device, so you can test everything in this tutorial without entering a credit card.

Sources and Verification

We verify every claim we make about RTILA X against real-world testing and public records. Our first GitHub release was on April 10, 2020. Our AppSumo launch in 2021 earned 116 reviews at a 4.7/5 average. Our Product Hunt launch in 2023 received a 5/5 rating. Trustpilot reviews are at 5/5. We exhibited at GITEX Africa 2026 in Marrakech.

External links for verification:

• AppSumo reviews at https://appsumo.com/products/marketplace-rtila-growth-hacking-marketing-automation-software/reviews/
• Trustpilot at https://www.trustpilot.com/review/rtila.com
• Product Hunt at https://www.producthunt.com/products/rtila-studio
• GitHub releases at https://github.com/rtila-corporation/rtila-releases/releases

FAQ: How to Automate Form Filling with RTILA X

Can I automate multi-step forms with conditional logic in RTILA X?

Yes. RTILA X includes full control flow commands such as if, else, while, for_each, and try_catch. You can branch based on variable values, wait for dynamic fields with wait_for_selector, and nest up to 50 levels deep. We tested a three-step checkout with payment method branching and verified the workflow filled the correct fields every time.

How do I reuse the same form filling automation for different data?

Use variables. Create variables manually or import them from a Dataset Builder, then reference them in fill, type, select_option, and other commands using the dollar sign plus curly bracket syntax. Combine with for_each and list_operation to process a whole list of records in one run.

Does RTILA X handle CAPTCHA challenges during form filling?

Yes. RTILA X integrates with 2Captcha to solve reCAPTCHA v2/v3, hCaptcha, Cloudflare Turnstile, and PerimeterX/DataDome. It also includes loop detection that resets the browser after three CAPTCHA detections and reports CAPTCHA_LOOP_DETECTED. Matching timezone and locale via ip-api.com and using the Humanoid Mouse at high sensitivity can reduce CAPTCHA frequency.

Written by the RTILA X team. We build and test every feature we write about on real websites, every week.