HandyTools Hub

Test Data Generator

Generate fake names, emails, phone numbers, addresses, and more

The Test Data Generator creates batches of fake records — names, emails, phone numbers, addresses, companies, dates, and Lorem Ipsum text — and exports them as JSON or CSV. It exists for the moments when a table is empty and the interface needs filling: seeding a development database, populating a form to test validation, or producing realistic-looking rows for a demo. Everything runs in the browser, so no data leaves your machine.

How to Use

  1. Select the fields you need by checking the boxes: name, email, phone, address, company, date, and Lorem Ipsum.
  2. Set the record count from 1 to 100.
  3. Generate — the table fills with a fresh random dataset for the chosen fields.
  4. Export as JSON or CSV, or use Copy All to place the JSON on your clipboard.

Worked Examples

Example 1 — seeding a users table. A new development database needs rows before the UI can be tested. Generate 50 records with name, email, and company, export as CSV, and import into the local users table. The application now renders a populated list, pagination is exercised, and the layout is tested against varied name lengths instead of a single repeated placeholder.

Example 2 — testing a signup form. Paste a generated email into the form to confirm the happy path processes, then tweak one character to test the rejection path. Because the generated addresses look realistic, they reveal layout problems — a long local part, a long domain — that test@test.com never would.

Example 3 — a demo environment. Client demos look wrong when every row reads “John Smith”. Fifty varied records with different companies and cities make a prototype feel like a live product, and the data is clearly synthetic rather than scraped from real users.

What Fake Data Does and Does Not Prove

It is worth being precise about the value here. Generated data proves that a shape works: your table renders, your CSV parses, your API accepts a payload with the expected keys. It does not prove that your business logic is correct — the generator does not know that a phone number must match a country format, that a coupon code has an expiry, or that a username must be unique. Tests for those rules need hand-written cases with specific valid and invalid values.

There is also a privacy upside. Because nothing is drawn from a real dataset, a demo built on generated data cannot leak a real customer’s details. That makes this a safer default than copying a production export into a staging environment.

JSON or CSV: Choosing the Export

  • JSON preserves structure and field names. Use it for API request bodies, NoSQL imports, and fixtures that a test runner will parse. Keys stay attached to values, so a field can be added or reordered without breaking the consumer.
  • CSV is a flat table. Use it for spreadsheet inspection, SQL COPY/import commands, and anything a non-developer needs to open. It is more compact, but it stores everything as text, so numbers and dates arrive as strings unless the importing tool casts them.

A common workflow uses both: export JSON to feed an API test and CSV to hand the same rows to a colleague for review.

Common Mistakes

  • Committing generated data as fixtures. Each run produces new random values, so tests that depend on specific rows will fail unpredictably. Generate once, save the file, and treat it as a fixture.
  • Assuming realism means validity. A plausible-looking email can still violate your application’s rules; test the rules separately.
  • Filling a production database. Generated values are not consented, verified, or intended to persist. Keep them in development and staging.
  • Mismatched field sets between runs. If two related exports select different fields, joining them by index breaks. Select the same fields for both, or join on a generated identifier.
  • Ignoring encoding on import. CSV imports with non-ASCII characters can arrive garbled if the tool assumes the wrong encoding; choose UTF-8 on import.

Features

  • Field types: name, email, phone, address, company, date, and Lorem Ipsum
  • Up to 100 records per run with instant preview in a table
  • Export as JSON (structured) or CSV (tabular)
  • Copy the full dataset to the clipboard
  • No registration, no server round trip
  • 100% client-side — generated data stays in your browser

Use Cases

  • Database seeding: Fill development and staging tables with varied rows.
  • Form and API testing: Produce realistic payloads for manual and automated tests.
  • UI prototyping: Populate mockups with believable long and short values.
  • Demos and screenshots: Give a prototype the density of real data.
  • Spreadsheet testing: Generate a table with mixed data types for formulas and pivots.

Frequently Asked Questions

Is the generated data safe to use in production?

Treat it as test-only. The values are randomly generated and do not describe real people or companies, but they are also not screened for collisions or policy risks — a generated email might land on a domain that exists, and a random address might be a real one. Use the data for development, QA, and demos, and keep production databases populated with real, consented data.

Does the generated data pass my validation rules?

Not necessarily, and that is often the point. The generator produces plausible shapes — a name looks like a name, an email looks like an email — but it does not know your business rules, such as password complexity, allowed country codes, or required field combinations. Use it to fill forms and tables, then write separate tests for the rules themselves.

What is the difference between the JSON and CSV exports?

JSON keeps the field names as keys and preserves data types, which suits API fixtures and NoSQL imports. CSV is a flat table that opens directly in a spreadsheet and imports cleanly into SQL databases and analytics tools. If your records contain nested or grouped fields, JSON is the safer choice; for tabular data, CSV is easier to work with.

Can I reproduce the same dataset later?

This generator produces fresh random values on every run, so a dataset is not reproducible by default. If a test suite needs stable fixtures, generate once, save the output to a file, and commit that file — deterministic fixtures belong in version control rather than being regenerated on each run.

How many records can I generate at once?

Up to 100 records per run, which is enough for form testing, UI mockups, and small fixtures. For load testing with thousands of rows, generate the shape of a record here and script the volume with a loop in your language of choice, or seed a database directly.

Are the names and companies in any way real?

They are assembled from common word lists, so an occasional combination may match a real person or business by coincidence. That is expected with random data — do not treat any generated value as fictional on purpose, and never publish it next to a claim that it refers to a real entity.

Reviewed by the HandyTools Hub team · Last updated