DevKits

Fake Data Generator — Realistic Mock Data for JSON, CSV, SQL, TypeScript

Generate realistic mock test data with 25+ field types (name, email, phone, UUID, address, company, IPv4, date, enum, and more). Output as JSON, JSONL, CSV, SQL INSERT statements, or TypeScript. Seeded, reproducible, and 100% local — a faker.js-style generator that runs entirely in your browser.

Last updated:

Comments

Pick a schema (users, orders, products…) or define your own fields, choose an output format (JSON / CSV / SQL INSERT), set a row count, and click Generate. Realistic mock data is produced entirely in your browser — nothing leaves the tab.

Fields (8)
1
2
3
4
5
6
7
8
Output 10 rows · 0 B

What is Fake Data Generator?

A fake data generator produces realistic-looking-but-synthetic records for testing, seeding development databases, and load-testing APIs. Unlike random junk (`asdf1234`), the values look like real ones: plausible names, valid-looking email domains, addresses that match locale patterns, phone numbers with correct country codes. This is what makes mock data useful — the tests exercise real parsing/validation paths, not just structural fields.

How to generate fake data

  1. 1Pick a preset schema (User, Order, Product, Post, Employee, Address) or click Custom to compose your own fields.
  2. 2For each field, choose a type: name, email, uuid, phone, address, date, number, boolean, category, url, image, custom regex, etc.
  3. 3Set the row count (1-10,000) and locale (en, zh, ja, fr, es, de, and more).
  4. 4Choose an output format: pretty JSON array, NDJSON (one object per line), CSV, or SQL INSERT statements.
  5. 5Click Generate. Copy the result or download as a file — the data is deterministic per seed if you provide one.

Use Cases

Seed a development database

Populate `users`, `orders`, `products` tables with realistic values so your local UI has something to render. Import the CSV or run the SQL directly.

Load-test an API

Generate 10,000 signup payloads with valid-format emails and phone numbers, then feed them into k6 / JMeter / Locust to hammer your endpoint.

Design demos and screenshots

Marketing needs a screenshot of your dashboard 'in the wild.' Generate 50 lifelike users so the demo doesn't look like `John Doe / Jane Doe / test@test.com` — those scream 'demo.'

Anonymize a real dataset

Replace real user names, emails, and phone numbers with synthetic ones (matching structure and locale) before sharing data with a contractor or in a bug report.

Code Examples

Same idea with Faker.js

import { faker } from "@faker-js/faker";

const users = Array.from({ length: 100 }, () => ({
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
  createdAt: faker.date.recent().toISOString(),
}));

Same idea with Faker (Python)

from faker import Faker
fake = Faker("en_US")

users = [{
  "id": fake.uuid4(),
  "name": fake.name(),
  "email": fake.email(),
  "created_at": fake.iso8601(),
} for _ in range(100)]

Produced SQL INSERT

INSERT INTO users (id, name, email, created_at) VALUES
  ('9a3f-…', 'Sarah Chen', 'sarah.chen@example.com', '2026-03-14T09:22:11Z'),
  ('2b81-…', 'Marcus Alvarez', 'marcus.a@example.com', '2026-03-14T09:22:12Z');

Key Concepts

Seeded vs. random
With a seed (any string), the same schema + row count reproduces byte-for-byte the same data every run. Use seeded generation for tests (deterministic assertions) and unseeded for exploratory demos.
Locale-aware fields
A name in `zh_CN` looks like `王小明`; in `fr_FR` like `Marie Dupont`; in `ar` like `أحمد محمد`. The same is true for addresses, phone number formats, and postal codes. Locale matters — English mock data will fail any real i18n test.
PII vs. synthetic data
Real user records contain PII (personally identifiable information) governed by GDPR / CCPA / LGPD. Synthetic data resembles PII in shape but is guaranteed to not identify anyone — safe to commit, share, and log.
Reserved test emails
Domains `example.com`, `example.org`, and `example.net` are IANA-reserved for testing (RFC 2606). Using them for mock data guarantees no accidental email delivery to a real person.

Tips & Best Practices

  • ▸Include edge cases explicitly: an empty string, a very long name (255+ chars), Unicode with combining marks (`é` vs `é`), and a null/undefined. Real data has them; your test data should too.
  • ▸For SQL INSERTs, keep row count under 1000 per statement — most databases have a limit and your import will fail past it. Use multiple statements or a `COPY` / `LOAD DATA` command for larger sets.
  • ▸When anonymizing production data, don't just replace fields — replace *and* shuffle them, so an attacker can't correlate 'user 1 in mock DB' with 'user 1 in real DB' by row order.
  • ▸Generate booleans with realistic distributions, not 50/50. Most real fields (`is_verified`, `is_paid_customer`) skew heavily in one direction — matching that catches UI bugs that only appear at extreme ratios.

Frequently Asked Questions

What field types are supported?

Over 25 built-in types: IDs (sequential, UUID v4), personal (first / last / full name, email, username, phone), address (street, city, country), business (company, job title), primitives (integer, float, boolean, enum), dates (date, datetime, ISO timestamp with range), network (IPv4, IPv6, MAC address, URL, user agent), text (Lorem sentence / paragraph), and colors (hex). Each field has type-specific config — e.g. integer min/max, date range, enum choices.

How do I get reproducible data (same output every time)?

Every run uses a numeric seed. Same seed + same field config = identical output, byte for byte. Copy the seed to your clipboard, share it with a teammate, and they'll see the same rows. Click the reset icon next to the seed field to randomize it, or type any integer you like.

Is my data sent to any server?

No. The whole generator — data lists, PRNG, formatter — runs in your browser. You can verify with DevTools Network panel: clicking Generate produces zero network traffic. The tool is safe to use for sensitive schemas (like PII-shaped tables) because nothing ever leaves your device.

What output formats work?

Five formats, one click to switch: (1) JSON array — the most common, use for fixtures / mocks; (2) JSONL / JSON Lines — one object per line, good for BigQuery / streaming ingest; (3) CSV — with correct quoting for values containing commas or newlines; (4) SQL INSERT — one INSERT per row with a configurable table name and proper string / NULL / boolean escaping; (5) TypeScript — a `type Row = {...}` declaration plus a typed array literal you can paste straight into code.

How is this different from faker.js?

Same idea, different constraints. faker.js is a Node / npm library with thousands of locales and edge cases. This tool is a browser-only version with a curated set of ~50 items per category — enough to look realistic for testing without the 500KB bundle. If you need more variety or specific locales (Japanese names, German addresses), install faker directly. For 90% of test-data needs — 'give me 100 fake users I can paste into my Postgres seed file' — this is faster.

Can I customize field types beyond the presets?

Yes. Click 'Add field', pick a type, and set a name. For integer / float, set min / max. For dates, set from / to. For enum, provide a comma-separated list of your own values (like 'admin, member, guest'). Fields can be added, removed, and reordered — the output reflects the row schema you build in real time.

Try Next

UUID v7 Generator

Generate UUID v7 identifiers online (RFC 9562). The first 48 bits encode a Unix millisecond timestamp, so v7 UUIDs sort lexicographically by creation time — dramatically better as a database primary key than v4. Bulk generate up to 1000 and inspect the embedded timestamp for each. 100% local.

Related Tools

Reference & Guides