FD
Fake Data Generator
Generate realistic-looking but entirely synthetic test data — names, emails, addresses and more — as JSON or CSV.
More Developer Tools Tools
Tick the fields you want, pick a row count, then generate. Every value is invented locally in your browser using small built-in word lists and Math.random() — nothing is looked up online and no real people are involved.
Column name
to
to
How to Use Fake Data Generator
Tick the fields you want (name, email, phone, address, company, job title, UUID, boolean, integer range, date), set a row count from 1 to 500, and generate. Every value is invented on the spot using small internal word lists combined with random numbers — nothing is looked up online, and no real person's data is used. Copy the JSON, or download it as a JSON or CSV file.
About Fake Data Generator
Developers and testers regularly need placeholder data — rows to fill a database while building a feature, sample records for a UI mockup, or a CSV to test an import pipeline — that looks plausible without being real. Using genuine customer or user data for this is a bad idea even in a supposedly "safe" development environment: it risks exposing real people's information, complicates compliance with data protection rules, and tends to leak into places it should not (screenshots, shared demo environments, support tickets). Purpose-built fake data avoids all of that by construction, since there is no real person behind any generated row to begin with.
This tool generates that data with a small, self-contained JavaScript generator running entirely in your browser: internal arrays of sample first names, last names, street names, cities, company name fragments, and job titles, combined using JavaScript's Math.random() to produce values that look like plausible records without being pulled from, or matched against, any real dataset. This is a deliberately lightweight approach compared to full-featured server-side or npm-package fake-data libraries — it does not aim to replicate every locale's naming conventions or postcode formats with fidelity, but it is more than sufficient for populating a dev database, testing a form's validation logic, mocking up a table in a UI prototype, or generating a CSV to check that an import script handles a given shape of data correctly.
Each field type generates a value independently: UUIDs use the browser's native crypto.randomUUID() where available (falling back to a manually constructed version-4 UUID pattern otherwise); names combine a random first and last name from the internal lists; emails derive a plausible-looking local part from the generated name and append a random placeholder domain (none of which resolve to real mail services); phone numbers follow a UK mobile-style pattern; addresses combine a random house number, street name, and city; companies combine a prefix, a business-focused word, and a legal suffix (Ltd, Group, etc.); job titles are picked from a list of common role names; booleans are a simple coin flip; integers respect whatever minimum and maximum you configure per field; and dates fall randomly within a configurable range, defaulting to the last several years up to today.
Each field also lets you rename its output column before generating, since the key a fake "name" field should use in your JSON or CSV often depends on the schema you are actually testing against — full_name, customer_name, and contact are all reasonable choices depending on context, and renaming the column here saves a manual find-and-replace afterwards.
Row counts are capped at 500 per generation, which keeps the tool fast and the output a manageable size for pasting or reviewing directly in the browser; if you need substantially more rows, generating a few batches and combining the files covers that case without meaningfully more effort.
Details & Tips
Available field types: UUID (a version-4 style unique identifier), Full name, Email, Phone (UK mobile-style format), Address (street + city), Company (invented trading name with a legal suffix), Job title, Boolean, Integer range (configurable min/max), and Date (configurable date range, defaulting to the last several years through today).
How values are generated: everything is produced with small, hardcoded internal word lists (first names, last names, street names, UK cities, company name fragments, job titles) combined using Math.random() for selection and numeric ranges. Nothing is fetched from an external API, looked up in a real database, or derived from any actual person's information — the resemblance to real-looking data is entirely coincidental and unavoidable given how names and addresses are structured, not a sign that any specific generated row corresponds to something real.
Output formats: the generated records display as formatted, indented JSON directly on the page (with a one-click copy button), and can additionally be downloaded as a standalone .json file or a .csv file. The CSV export uses standard comma-separated formatting with values containing a comma, quote character, or line break automatically wrapped in double quotes (and any internal quotes doubled), following the same escaping convention used by spreadsheet applications like Excel and Google Sheets, so the file opens cleanly without misaligned columns.
Customising columns: every field can be renamed before generating (the "Column name" box under each checkbox), which controls the actual JSON key or CSV header used in the output — useful when you are testing against a specific schema, such as renaming the generated "name" field to full_name or contact_name to match your database columns exactly.
Practical uses: seeding a local development database so a UI has realistic-looking content to render against, populating a demo or staging environment without using real customer records, generating a CSV to validate that an import or ETL script parses columns correctly and handles a range of data types (integers, booleans, dates, text with occasional special characters), and quickly mocking up a table or list view in a design prototype. Because the data is synthetic by construction, it carries no personal-data handling obligations the way a copy of real production data would, which makes it safe to commit into a repository's seed/fixture files, share in a bug report, or paste into a public forum when asking for help.
Limitations to keep in mind: the word lists are intentionally small and UK/English-leaning (this is a UK-focused toolbox), so very large row counts will show repeated names and companies rather than truly unique variety — for genuinely large-scale, highly varied datasets, a dedicated data-generation library with much larger source lists would be a better fit. The row count is capped at 500 per click to keep the tool responsive; generate multiple batches and merge the files if you need more.
Frequently Asked Questions
Is the generated data based on real people?
No. All values are built from small internal word lists (sample first names, last names, street names, companies, etc.) combined randomly. There is no lookup against any real dataset or real individual — any resemblance to a real name or address is coincidental.
Is it safe to use this data in a shared or public repository?
Yes, that is one of the main reasons to use synthetic data instead of a copy of real records — since nothing generated here corresponds to an actual person, it does not carry the same data protection or privacy concerns that real customer data would.
How many rows can I generate at once?
Between 1 and 500 rows per generation. If you need more, generate a few batches and combine the exported files.
Can I rename the output fields?
Yes, each field has a "Column name" box that controls the exact JSON key or CSV header used in the output, so you can match your own schema without editing the file afterwards.
What format is the phone number in?
A UK mobile-style format (e.g. +44 7### ######). If you need a different country's format, you can find-and-replace the prefix in the exported file, though the underlying digits will remain random.
Does the email field generate real, deliverable addresses?
No. Email addresses use placeholder domains that are not configured as real mail services, so generated addresses will not actually receive mail.
Can I control the range for integer or date fields?
Yes. Ticking the Integer range or Date field type reveals min/max (or date range) inputs so you can constrain the generated values to whatever range fits your test case.
Is my data sent anywhere when I generate or download it?
No. Generation, JSON formatting, and CSV building all happen locally in your browser, and downloads are created from an in-memory file rather than a server response.
Why do I see repeated names when I generate a lot of rows?
The internal name lists are intentionally compact, so with larger row counts the same first or last names can reappear. This is expected — for genuinely large, highly varied datasets, a dedicated data-generation library with much bigger source lists would suit better.
What does the UUID field produce?
A version-4 style unique identifier, generated using the browser's native crypto.randomUUID() where supported, with a manual fallback pattern for older browsers.
How is the CSV file quoted and escaped?
Any value containing a comma, double quote, or line break is wrapped in double quotes, with internal double quotes doubled — the same convention spreadsheet software like Excel and Google Sheets uses, so the file opens without misaligned columns.
Can I generate a boolean or true/false column?
Yes, the Boolean field type produces a random true or false value for each row, useful for testing flags like "is_active" or "is_verified".
Part of These Collections
Also Available As
fake data generator, mock data generator, test data generator, dummy data generator, faker alternative online, sample json generator, sample csv generator
Found a Problem?
Let us know if something with Fake Data Generator isn't working as expected.
Something went wrong. Please try again.
Thanks — we'll take a look.