If you know me, you know how much I hate filling forms online. I mean everybody hates filling out the same information over and over on different websites.
That's the core reason why I built Skyvern in the first place, to automate it with the help of AI. Unlike traditional automation tools that break every time a website updates, our approach uses computer vision and LLMs to adapt to any form it encounters, making the whole process actually reliable.
In this article, I go over what AI enables in browser automation, and then show you how to fill a form by giving Skyvern a task (you'll see how simple it is!).
We'll cover logins, CAPTCHAs, and human review before filling forms programmatically with Python and TypeScript.
Read-on!
How has automated form filling changed with AI? #
Automated form filling used to rely on scripts and logic that can break whenever there is a change in the target form fields, or whenever there is an error or something outside of the happy path happening on screen.
Instead, AI browser automation tools like Skyvern use screenshots, page structure and AI to decide what to do next.
So you can describe a form task without having to program any logic first.
| Part of the job | Before: write a script for the form | After: give an AI browser agent the task |
|---|---|---|
| Find the right fields | Identify each input and map your data to it. | Give the agent your data. It reads labels and page context to find the fields. |
| Handle widgets and extra pages | Write the interactions for dropdowns, date pickers, and each conditional step. | The agent examines the current page and chooses the next action as fields appear. |
| Deal with site changes | Update selectors or recorded steps when they stop matching the page. | The agent can locate fields from the current page, reducing dependence on a fixed layout. |
| Check the result | Write assertions for required values, validation errors, and confirmation messages. | Describe the expected result and ask the agent to return the confirmation or accepted values. |
Now let's see what it looks like in Skyvern.
How to automatically fill out forms with Skyvern's AI browser agent #
Well, it's super simple:
- Give the agent the page URL
- Tell it what to do using natural language
- That's it!
The agent will figure out where to click, how to open dropdowns and how to deal with errors
For example:
Go to my-form-url.com and fill out the form with the proper information, then click on submit. The task is complete when the page shows Successfully submitted! Output the confirmation text you see.
You can tell it exactly what information to fill (useful for testing), or point the agent at your source of truth (recommended approach for production).
In Skyvern's app it looks like this:
-
On "Create an agent ", enter your goal and data in the prompt box.
-
The studio opens with a Copilot pane, an editor, and a live browser. You can review the the workflow Copilot drafts from your request.
-
Start the task, then check the filled fields and the returned confirmation.
And now the magic happens. The agent goes to the target URL and figures out what fields to fill with the information you gave it.
Even if there are errors, or changes popping-up, it will still work around them to achieve its goal.
Our clients use it to automate heavy and repetitive form filling workflows like EOB processing and credentialing in Healthcare, or claims processing in the insurance space...
The use-cases are infinite. Whenever there is a time consuming workflow that involves filling-up data in a form, Skyvern can automate it and save time.
How do you fill a form behind a login wall? #
When you need to be logged-in, the best approach is to use Skyvern's saved credentials and a Login block before the form task:
- Save the login details in Skyvern's vault,( or connect an existing vault through Bitwarden, 1Password, or Azure Key Vault)
- Add the credential as an agent parameter
- Reference it in the Login block
Now the agent can use the credentials stored in the vault as needed, without sharing anything in the prompts.
Yes Skyvern handles 2FA
If the portal requires two-factor authentication, Skyvern can handle it as well.
You just need to configure the 2FA method you want to use:
- For authenticator apps, store the TOTP secret so Skyvern can generate a code during the run.
- For email or SMS codes, send the code through the API or provide an endpoint Skyvern can poll.
- For magic links, send the login URL so the agent can follow it.
Please note: Vault integrations and 2FA availability depend on your plan and are not available on the free plan.
What about CAPTCHAs?
Skyvern Cloud detects CAPTCHAs and attempts to solve them during the run.
Supported types include reCAPTCHA, hCaptcha, and Cloudflare Turnstile.
Solving is not 100% guaranteed. We have a high success rate but a challenge may still need a person.
Self hosted deployments provide a manual intervention window instead of automatic CAPTCHA solving.
What happens when the agent needs a human? #
Human intervention during automated form filling can occur on 2 occasions:
- When obstacles that prevent the agent from completing its task arise (for example if it doesn't have the data needed to fill a form)
- When you want to add a review step, to have a human verify and validate the data before continuing the automation
Skyvern handles both situations differently.
For an unexpected obstacle, you can use Take Control:
- Click Take Control in the live browser panel. The agent s and you get mouse and keyboard control.
- Make the correction in the browser.
- Click Release Control. The agent continues from the page you leave it on.
For a planned review, the approach we recommend is to add a Human Interaction block before the submission step.
It s the workflow, displays instructions, and can email reviewers with Approve and Reject actions.
You can also add an AI Validation block to check the any filled form before proceeding and flagging any error for human review.
How to fill forms programmatically with Skyvern #
Alright. So far we looked at automated form filling with some data we shared with the agent.
Now we'll unlock the true power of automation: filling out the same forms programmatically. It can be with your clients data, your providers, yourt patients.... It can come from CSVs, a database, your stored records...
It's simple, your code supplies each record, sends the task to Skyvern, and collects the result.
The core instructions stay the same: give the agent the form URL, the data, and the result it should verify.
The examples below use Skyvern's REST API, which also drove the measured runs in this article:
- Create a task with
POST /v1/run/tasks. - Use the returned run ID to poll
GET /v1/runs/{run_id}until the run finishes. - Keep the status, output, and any failure reason alongside the source record.
You can find the API key in Skyvern's settings and pass it through the SKYVERN_API_KEY environment variable. Replace the sample form URL in each script with your target form.
Bulk automated form filling script in Python
For bulk work, you can put one submission per CSV row and send each row through the same task.
For this example, you'll need to install requests and prepare a leads.csv file with name, phone, and email columns.
This script creates one task per row, waits for its result, and prints the result beside the row's name:
import csv
import os
import time
import requests
BASE = "https://api.skyvern.com"
HEADERS = {"x-api-key": os.environ["SKYVERN_API_KEY"]}
def run_task(prompt, url, max_steps=8):
response = requests.post(
f"{BASE}/v1/run/tasks",
headers=HEADERS,
json={"prompt": prompt, "url": url, "max_steps": max_steps},
timeout=60,
)
response.raise_for_status()
run = response.json()
while True:
response = requests.get(
f"{BASE}/v1/runs/{run['run_id']}", headers=HEADERS, timeout=60
)
response.raise_for_status()
state = response.json()
if state["status"] not in ("created", "queued", "running"):
return state
time.sleep(15)
with open("leads.csv", newline="", encoding="utf-8") as source:
for row in csv.DictReader(source):
prompt = (
f"Fill out the order form for {row['name']}, phone {row['phone']}, "
f"email {row['email']}. Submit, then output the confirmation values."
)
result = run_task(prompt, "https://example.com/order-form")
print(
row["name"], result["status"], result.get("output"),
result.get("failure_reason"),
)
Bulk automated form filling script in TypeScript
The same pattern works in a TypeScript application using Node's built-in fetch.
Here, rows represents records loaded by your application. Replace the sample record with your own data.
const BASE = "https://api.skyvern.com";
const HEADERS = {
"x-api-key": process.env.SKYVERN_API_KEY!,
"Content-Type": "application/json",
};
const rows = [
{ name: "Maya Okafor", phone: "415-555-0101", email: "maya.okafor@example.com" },
];
async function readJson(response: Response) {
if (!response.ok) throw new Error(`Skyvern API returned ${response.status}`);
return response.json();
}
async function runTask(prompt: string, url: string, maxSteps = 8) {
const created = await fetch(`${BASE}/v1/run/tasks`, {
method: "POST",
headers: HEADERS,
body: JSON.stringify({ prompt, url, max_steps: maxSteps }),
}).then(readJson);
while (true) {
const state = await fetch(`${BASE}/v1/runs/${created.run_id}`, {
headers: HEADERS,
}).then(readJson);
if (!["created", "queued", "running"].includes(state.status)) return state;
await new Promise((resolve) => setTimeout(resolve, 15000));
}
}
async function main() {
for (const row of rows) {
const prompt =
`Fill out the order form for ${row.name}, phone ${row.phone}, ` +
`email ${row.email}. Submit, then output the confirmation values.`;
const result = await runTask(prompt, "https://example.com/order-form");
console.log(row.name, result.status, result.output, result.failure_reason);
}
}
main().catch(console.error);
Both scripts run submissions in sequence and print their results.
For a production batch, we recommend saving those results with each source record and compare the returned values with the inputs.
This you can route failed or incomplete rows for review before retrying them.
If you want to manage the batch in Skyvern, use a workflow with a Loop block for the records. Add extraction, validation, and review steps inside the loop.
Start for free #
As you've seen, Skyvern can automate form filling in a robust and reliable way.
We've built it specifically to automate business workflows, with all the features needed to make it reliable, repeatable and scalable.
It's super easy to get started, you can get your first automation running in just a few minutes and you can do it for free!