How to Autofill Forms With Your Own Data (CSV, Spreadsheets & Repeat Fills)

There are two completely different things people mean by "autofill forms with your own data."

The first is the everyday one: you want your name, address, and email to drop into a checkout without retyping them. Chrome already does this, and it does it well.

The second is the one almost no tool handles cleanly: you have a spreadsheet of data — 20 test accounts, 50 customer records, a list of edge-case phone numbers — and you need to push that data into a web form. Often the same form, over and over, one row at a time.

This guide covers both, but it spends most of its time on the second — because that's where the built-in tools fall apart and where people waste the most time.

What "your own data" actually means

Quick gut check, because it decides which method you need:

• "My personal details" — one identity, reused everywhere. → Chrome's built-in autofill is the answer.
• "A set of records I keep in a file" — many rows, many fields, used repeatedly. → You need a form filler that reads from your data, not a built-in profile.

If you're in the second group, skip ahead — but here's the fast version of the first.

Method 1: Chrome's built-in autofill (for personal info)

For your own contact and payment details, you don't need anything extra:

1. Open Chrome → Settings → Autofill and passwords.
2. Add or edit your address and payment info.
3. On any form, click a field and pick your saved profile.

This is great for you filling out your forms. Its limits show the moment your data lives outside that one profile:

• One identity only. No second persona, no test accounts, no "fill with row 7."
• It guesses fields by type — you can't say exactly what goes where.
• It's built for real personal data, not the test data a developer or QA tester works with.

The same applies to password managers: one real identity, the wrong job for everything below.

Method 2: Random / fake-data fillers (when you don't care what the values are)

If you just need something in every field to test a form — any name, any email — a random filler does it in one click. Tools like Fake Filler popularized this, and it's genuinely useful for a quick smoke test.

But "random" is the catch. The whole point of your own data is that this specific value goes into the form — a real customer name, a known-bad IBAN, the exact phone format that broke production last week. A random filler can't give you that, and it can't reproduce the same input twice. (Worth noting: Fake Filler itself hasn't been updated since August 2024.)

Newer fillers like MockFill generate more realistic-looking data and detect field types well — but it's still generated data. There's no saved configuration per form, and no way to fill from a file you control.

So if the values matter, keep reading.

Method 3: Autofill a form from a CSV or spreadsheet

This is the request that sends people in circles: "I have a CSV — how do I get it into this web form?"

A handful of small extensions read a CSV and map columns to fields (search "CSV to form autofill" and you'll find several). They work, but most share the same rough edges:

• You re-upload or re-map the file every session.
• Mapping is fragile — rename a column and it breaks.
• No saved per-field rules (some fields you want fixed, some generated, some left blank).
• No clean way to walk through rows one at a time and know which row you're on.

For a one-off import that's fine. For a form you fill every day, the setup cost comes back every time.

Method 4: Presets + datasets — autofill with data you control

This is the approach built for the second meaning of "your own data," and it's how Fillr works. The idea is two pieces that click together:

Capture the form once as a preset. Point Fillr at any web form and it captures every field. For each field you set a rule once: Generate · Fixed value · Blank · Skip · Dataset column. Next time you land on that page, the right preset finds you automatically (it matches the URL) and one click fills the whole form exactly the way you set it up.

Drive it with your own dataset. Import a CSV, Excel, or JSON file — or build the rows by hand — and link it to the preset. Fillr maps your columns to the form's fields. Now each fill pulls a real row from your data:

• Sequential mode walks row 1, row 2, row 3… with a visible "row 3 of 20" readout, so you always know exactly which record you just submitted.
• Random mode picks a row at random when you want variety.

That row readout is the part that matters for anyone testing: when something breaks, you can say which row did it. That's reproducibility — the thing random fillers and built-in autofill can't give you.

Everything stays yours: presets and datasets live in your account, visible only to you. The extension stores no passwords or tokens, filling happens locally in your browser, and nothing is captured unless you explicitly save it.

Side-by-side: which method fits your data

	Chrome autofill	Random / fake fillers	CSV-only extensions	Fillr (presets + datasets)
Fills personal info	✅	⚠️ random only	⚠️ manual	✅
Fills from your own file (CSV/Excel/JSON)	❌	❌	✅	✅
Saves per-form setup (presets)	❌	❌	❌	✅
Per-field rules (fixed / generate / skip)	❌	⚠️ limited	⚠️ limited	✅
Fill same form repeatedly, row by row	❌	❌	⚠️ clunky	✅
Tells you which row was used	❌	❌	❌	✅ "row 3 of 20"
Realistic generated data when you want it	❌	✅	❌	✅ 120+ types, 60+ languages
Data stays local / private	✅	✅ usually	✅ usually	✅

No single built-in tool spans "fill from my file" and "save the setup" and "tell me which row." That combination is the gap.

Walkthrough: fill a form from your spreadsheet, step by step

Using Fillr as the example, start to finish:

1. Install the extension and open the form you fill often.
2. Capture it as a preset — Fillr grabs every field. Set a rule per field if you want (e.g. email = Fixed value, signup date = Generate, internal-notes = Skip).
3. Import your data as a dataset — drop in a CSV, Excel, or JSON file. Fillr reads your columns.
4. Link the dataset to the preset. Fillr auto-maps columns to fields by their names; fix any it couldn't match.
5. Pick a fill mode — sequential to march through every row, random to sample.
6. Click fill. The form populates from the next row, and you see "row N of M" so you know exactly where you are. Submit, click again, next row.

Set up once. After that, every fill is one click with the data you chose.

FAQ

How do I autofill a form from a CSV file? Use a form filler that imports CSV and maps columns to fields. In Fillr: import the CSV as a dataset, link it to the form's preset, and each fill pulls one row. Your column headers auto-map to the matching fields.

How do I fill the same form repeatedly with different data each time? You need a tool with a dataset and a row cursor, not a random filler. Fillr's sequential mode advances through your rows — row 1, row 2, row 3 — showing "row N of M" each time, so every submission uses a different, known record.

Can I autofill a form with realistic fake data instead of my own? Yes. Set fields to Generate and Fillr produces realistic values — 120+ data types across 60+ languages — for any field you don't want to pull from your file. Mix and match: some fields from your data, some generated.

Is it safe to put my own data into a form filler? With Fillr, your presets and datasets are stored in your own account and visible only to you. The extension keeps no passwords or tokens, filling runs locally in your browser, and a form is only captured when you explicitly save it.

Does Chrome's built-in autofill work for this? Only for one set of personal details. It can't hold multiple records, fill from a file, or fill the same form with a different row each time. For test data or any multi-record workflow, you need a dedicated form filler.

Does it work on internal tools and staging sites? Yes — any web form, including admin panels, internal apps, and localhost/staging. URL patterns match your environments, and nothing is installed on the site itself.

The short version

Browser autofill is for your one personal identity. Random fillers are for "any value will do." But when the values matter — when you're filling the same form again and again with data you keep in a spreadsheet — you want control: a saved setup, a rule per field, and your own rows driving the fill, one knowable row at a time.

That's exactly what Fillr is built for. Add it to Chrome and fill your next form from your own data in one click.