Getting started

1 · Design a schema

The schema builder is a list of fields. Each field has a name (which becomes the JSON key, CSV column or SQL column), a type from the field type reference, per-type options, and a Blank % that injects nulls at that rate — perfect for testing how your app handles missing data.

Not sure where to start? Use Load a template… for ready-made schemas: users, e-commerce orders, employees, IoT sensor readings or bank transactions. Your schema is auto-saved to localStorage, so it survives a refresh.

2 · Configure rows, format and seed

Pick 1 to 100,000 rows and one of six formats. A quick cheat sheet:

• CSV / TSV — spreadsheets, BI tools, COPY imports. Optional header row.
• JSON — a pretty-printed array; drop it into a mock API or fixture file. Field names containing dots nest: address.city becomes {"address":{"city":…}}.
• NDJSON — one object per line (dot-nesting applies here too); streams nicely into jq, Elasticsearch or BigQuery.
• SQL — INSERT statements with an optional CREATE TABLE whose column types are inferred from your fields. Pick a dialect (PostgreSQL double quotes or MySQL backticks) and optionally batch 250 rows per INSERT for much faster imports.
• XML — <records><record>… for legacy integrations.

The Seed field is the power feature: any string (a ticket number, a build id) makes generation deterministic. Same seed + same schema = byte-identical output, today and in six months. Leave it empty for fresh random data on every run.

3 · Export

Download ↓ saves a file named like fundata_1000_rows.csv; Copy data puts the full output on your clipboard; Copy JS fixture copies the rows as a paste-ready export const rows = […] module with a link that reproduces the exact dataset; and Copy schema link encodes your entire schema into a URL you can send to a teammate — opening it recreates your exact setup.

To keep the schema itself rather than a sample of data, use Export schema ↓ to save it as a JSON file (and Import schema ↑ to load one back — handy for checking a fixture definition into a repo). Or save it under a name in My saved schemas to switch between several schemas in this browser without losing any of them. Already have real-shaped data? Import CSV sample reads a CSV/TSV file and infers a schema from it — column types, numeric ranges, date ranges, small value lists and blank rates are guessed from the actual values, ready to tweak.

Optional account

Everything above works with no account at all — schemas, datasets and history stay in this browser's localStorage. Sign in with an email and password (top-right) to sync all of it to your account instead, so it follows you to another device:

• My saved schemas and My datasets — reusable value lists for the My Dataset field type, one value per line.
• Recent generations — the last 20 downloads/copies, restorable with one click.
• Settings — rows, format, seed, table name and theme.
• Cloud share links — a short, revocable /#g=… URL for a schema, listed under “More schema actions” so you can pull it back at any time.

Recipes

Seed a Postgres table

-- 1. Choose format: SQL, table name: customers, "Create table" checked
-- 2. Download and run:
psql -d mydb -f fundata_1000_rows.sql

Data-driven tests (Playwright)

// Export JSON with seed "sprint-42" so every CI run uses identical fixtures
import users from './fixtures/fundata_100_rows.json';

for (const user of users.slice(0, 10)) {
  test(`signup works for ${user.email}`, async ({ page }) => {
    await page.goto('/signup');
    await page.fill('#email', user.email);
    await page.fill('#first-name', user.first_name);
    // …
  });
}

Stream NDJSON into jq

jq -s 'group_by(.country) | map({country: .[0].country, users: length})' \
   fundata_10000_rows.ndjson

Good to know

• Privacy: generation is 100% client-side — the rows themselves are never uploaded anywhere. Your schema stays in this browser unless you sign in, which is entirely optional.
• Sensitive-looking fields are fake: credit card numbers use official payment-gateway test PANs and IBANs are country-length-shaped but not bank-valid.
• Emails are safe: generated addresses use reserved documentation domains like example.com, so accidental sends can't reach real people.
• Selectors for automation: every control carries a stable data-testid — this site doubles as a practice target, just like its siblings funui.dev and funapi.dev.
• Works offline: after your first visit the generator is cached by a service worker, so schema building and exports keep working without a connection (account sync naturally needs one).

Next, choose a complete pattern from the test-data use cases, or review how synthetic values are produced in the privacy and safety methodology.

Common questions

How do I generate test data with this tool?

Add fields to the schema, choose a type for each one, set the row count and format, then press generate and download. Nothing else is required — there is no account, and the rows are produced in your browser rather than fetched.

Last updated 6 September 2026