How to Automate Form Filling

Step 1: Analyze the Target Form

Before writing any automation code, study the form you want to automate thoroughly. Open the form in your browser and use the developer tools (F12 or right-click, then Inspect) to examine each field. Identify the input types: text fields, email fields, password fields, dropdowns (select elements), radio buttons, checkboxes, date pickers, file upload fields, and textareas. Note the field names, IDs, and any data attributes that could serve as stable selectors.

Pay attention to dynamic behavior. Many modern forms use JavaScript to show or hide fields based on previous selections, validate input in real time, load dropdown options from an API, or split the submission across multiple pages (wizard-style forms). Check whether the form uses a CAPTCHA (reCAPTCHA, hCaptcha, or custom implementations) and whether it requires authentication before access. Also note any confirmation steps, success messages, or redirect behavior after submission, since your automation needs to verify that each submission actually completed.

If the form is a multi-step wizard, document the sequence of pages, which fields appear on each step, and what triggers the transition between steps (a "Next" button, automatic progression after all fields are filled, or similar). Multi-step forms require your automation to handle each page transition and wait for the next set of fields to load before continuing.

Step 2: Prepare Your Data Source

Organize the data you will submit into a structured format that your automation can read programmatically. The most common formats are CSV files (which can be exported from any spreadsheet application), JSON files, or direct connections to databases and APIs. Each row in your data source represents one form submission, and each column maps to a specific form field.

Clean your data before feeding it to the automation. Remove leading and trailing whitespace, standardize phone number and date formats to match what the form expects, ensure email addresses are valid, and verify that dropdown values match the exact options available in the form. A form that expects "California" will reject "CA" or "california" unless the automation also handles the conversion. Data quality issues are the most common source of failed automated submissions.

For large datasets, consider adding a status column to your data source that tracks whether each record has been submitted successfully, failed, or is pending. This lets you resume from where you left off if the automation is interrupted, and makes it easy to identify records that need manual attention.

Step 3: Choose Your Automation Tool

For code-based automation, Playwright is the strongest choice for form filling due to its auto-waiting capabilities, which handle the timing complexities of dynamic forms without explicit sleep statements. Its API provides dedicated methods for filling text inputs, selecting dropdown options, checking checkboxes, uploading files, and clicking buttons, each with built-in waits for the element to become actionable.

For non-developers, no-code tools like Axiom.ai, Bardeen, and Browserflow offer visual form filling automation. These tools let you record yourself filling out the form once, then replay that recording with different data for each submission. The tradeoff is less flexibility for handling complex conditional logic and error recovery, but the setup time is dramatically shorter for simple forms. See our no-code web automation guide for platform comparisons.

Step 4: Build the Form Filling Script

The core automation logic follows a consistent pattern regardless of the tool you choose. Navigate to the form URL. Wait for the form to fully load (including any JavaScript-rendered fields). Locate the first field using a stable selector. Clear any pre-filled value. Enter the data. Move to the next field and repeat. After all fields are filled, locate and click the submit button. Wait for the submission to complete and verify the result.

Use the most stable selectors available. In order of reliability: data-testid or data-automation attributes (most stable, since they exist specifically for automation), element IDs (stable if the developers maintain them), ARIA labels (stable and meaningful), name attributes on form fields (usually stable), and CSS class selectors (least stable, especially with CSS-in-JS frameworks that generate random class names). Avoid XPath expressions based on DOM position, since these break whenever the page layout changes.

For dropdown fields, the approach depends on whether the dropdown is a native HTML select element or a custom JavaScript-rendered component. Native selects can be filled using the automation tool's built-in select method (like Playwright's selectOption). Custom dropdowns typically require clicking the trigger element, waiting for the option list to appear, and clicking the desired option, essentially mimicking the human interaction flow.

Date pickers, particularly calendar-style date pickers built with JavaScript libraries, often require special handling. Some accept direct text input into the underlying field, which is the simplest approach. Others require clicking through calendar navigation to select the correct month, year, and day. Test both approaches and use whichever works reliably for your specific form.

Step 5: Handle Errors and Edge Cases

Production form filling automation must handle failures gracefully. Network errors can interrupt page loads. Server-side validation may reject submissions that passed client-side validation. Session timeouts can invalidate the authentication state. CAPTCHAs can appear unexpectedly after several rapid submissions. The form itself may display error messages that need to be read and logged.

Implement a try-catch wrapper around each submission attempt. When a submission fails, log the error details (including a screenshot and the page source if possible), mark the record in your data source as failed, and continue to the next record rather than stopping the entire batch. After all records have been attempted, generate a summary report showing how many succeeded, how many failed, and the reasons for each failure.

For forms protected by CAPTCHAs, you have several options depending on the CAPTCHA type. Some automation frameworks include CAPTCHA solving integrations. For reCAPTCHA v3 (invisible), your automation may pass without triggering a challenge if you use headed mode with realistic browsing behavior. For visual CAPTCHAs that require human solving, consider CAPTCHA solving services or designing your workflow to pause and alert a human when a CAPTCHA appears.

Step 6: Scale to Bulk Submissions

Once your automation reliably fills a single form, scaling to bulk submissions requires adding delays, monitoring, and tracking. Insert a random delay between submissions (typically 2 to 10 seconds for most websites) to avoid triggering rate limits or anti-bot detection. The exact delay depends on the target website's tolerance, which you should test incrementally.

Monitor your automation while it runs, at least for the first few batches. Watch for increasing error rates, which may indicate the website has started throttling or blocking your submissions. Track submission speed and success rates over time. If you notice a pattern where the first 50 submissions succeed but then failures start appearing, the website may be rate-limiting based on IP address, session, or submission volume.

For very large datasets (thousands of submissions), consider running the automation in batches with longer pauses between batches, rotating IP addresses if appropriate and permitted, and distributing submissions across multiple time windows. Always verify a sample of submitted data by checking the target system to confirm the information was recorded correctly.