JSON Mock Data Generator

JSON Mock Data Generator

Generate realistic mock JSON data for testing and prototyping — users, products, orders, and custom schemas. Runs entirely in your browser.

Updated April 2026

Ctrl + Enter to Generate · Shift + Enter to Copy · Shift + ↑ ↓ template
FIELDS
UUID
NAME
USER
EMAI
PHON
ADDR
LORE
ENUM
BOOL
Generating… 10 / 10
MOCK_DATA.json
Generating… 100%

10 / 10

Test Data Generator — Generate Fake Data as JSON or CSV (Up to 10 Million Records)

Need fake data right now? This free test data generator creates realistic mock datasets in seconds — pick a template, customize the fields, set the record count, and download as JSON or CSV. No libraries to install, no API keys, no account required.

Whether you're seeding a database, testing a REST endpoint, populating a CSV for Excel or pandas, building a React prototype before the backend exists, or loading a Postman collection with data that looks real — this fake data generator delivers what you need instantly.

How to Use the Fake Data Generator

  1. Pick a template — choose from Users, Products, E-commerce Orders, Blog Posts, or start from scratch with Custom.
  2. Edit the fields — rename any field, change its data type, add new fields with the + Add Field button, or remove the ones you don't need.
  3. Set the record count — from 1 to 10,000,000 records. For counts above 10,000, the output is downloaded automatically instead of previewed in the browser.
  4. Choose the format — toggle between JSON and CSV in the output panel header before downloading.
  5. Click Generate — your data appears instantly. Click Download to save it, or Copy for smaller outputs.

Enable "Wrap with pagination" to get a JSON response envelope like { data: [...], page: 1, total: 50, perPage: 10 } — perfect for mocking paginated API responses. When downloading as CSV, the tool automatically extracts just the data rows.

Generate Mock Data as CSV

The CSV download option makes this generator useful far beyond API testing. Load the output directly into:

  • Excel or Google Sheets — for QA teams reviewing test data without touching code
  • pandas / polars — pd.read_csv("mock-data.csv") and you have a realistic DataFrame in one line
  • database seed scripts — COPY table FROM 'mock-data.csv' (PostgreSQL) or LOAD DATA INFILE (MySQL)
  • data pipeline testing — validate ETL transformations with deterministic but realistic input data
  • BI tools — Tableau, Power BI, Metabase — load sample data before the real source is ready

CSV values are RFC 4180 compliant: commas, quotes, and newlines inside field values are correctly escaped. Nested objects and arrays are stringified as JSON within the CSV cell.

Generate 10 Million Records

Most mock data tools cap at a few thousand records. This generator supports up to 10,000,000 records in a single run. For datasets above 10,000 records, the output is streamed directly to a file download instead of being shown in the preview panel — keeping the browser fast regardless of scale.

Use cases for large fake datasets:

  • Load testing a database query or index with realistic volume
  • Benchmarking a CSV parser, ETL pipeline, or data warehouse import
  • Generating training data for ML models that need realistic-looking text, numbers, or categorical values
  • Stress testing a paginated API endpoint with production-scale record counts

Mock JSON Data for APIs

When you're building or testing an API integration, you need a realistic mock API response — not {"name": "test", "id": 1}. This generator creates properly structured payloads with UUIDs, ISO timestamps, realistic emails, enums, and nested objects, so your frontend handles real-world data shapes from day one.

Drop the output into Mockoon, json-server, or MSW and you have a running fake API in under two minutes. The pagination wrapper option mirrors the response format used by Laravel, Rails, and most Node.js REST frameworks.

Sample E-commerce JSON Data

The built-in E-commerce Orders template generates sample data ready for checkout flows, order history UIs, and payment gateway testing. Each record includes:

{
  "order_id": "8f14e45f-ceea-467a-a866-085d6b78c8e1",
  "customer_name": "Marcus Rivera",
  "total_amount": 134.99,
  "payment_status": "PAID",
  "created_at": "2025-11-03",
  "items_count": 3
}

The Products template is equally useful for catalog and search UIs:

{
  "id": "a87ff679-a2f3-471d-8326-ee4758c0f1e4",
  "name": "Wireless Mechanical Keyboard",
  "price": 89.99,
  "sku": "WMK-7842",
  "category": "Electronics",
  "in_stock": true,
  "rating": 4.3
}

Use the Custom schema if your e-commerce data model differs — add discount_percent, currency_code, shipping_address (nested), or any field your project needs.

Fake Data for Frontend Testing

Frontend developers are constantly waiting on APIs. Instead of hardcoding const users = [{name: "Test User"}] into your component, generate 50 realistic user records and import them as a JSON fixture. Your components will face realistic data shapes — long names, nested addresses, boolean edge cases — before the API ever exists.

The Users template includes everything a typical user management UI needs: UUID primary key, full name, username, email, phone, nested address object, company, job title, and an active flag. Generate it once, save it to src/fixtures/users.json, and import it wherever you need it.

Supported Field Types

Each field can be one of 18 data types:

  • UUID — RFC-compliant v4 UUID
  • Full Name / First / Last Name — realistic human names from a diverse pool
  • Email — derived from the record's name, always valid format
  • Username — slug-style login like alice.chen42
  • Phone — US-formatted number (+1 (555) 012-3456)
  • Number / Integer — random float or integer within your min/max range
  • Boolean — random true or false
  • Date — ISO date string, distributed over the last two years
  • Timestamp — Unix millisecond timestamp
  • Currency — float with two decimal places (e.g. 49.99)
  • Enum — random pick from your comma-separated values
  • Array (Enum) — 2–4 random values from your enum list
  • Lorem — random Latin placeholder sentence
  • URL — plausible-looking fake URL under example.com
  • Address — nested object with street, city, and zip

Frequently Asked Questions

What is the best way to generate fake data for API testing?

Use a template that matches your API's response shape, then customize the fields to match your exact schema. Set the record count to match typical pagination sizes (10, 20, 25) and enable the pagination wrapper so the envelope structure matches what your API actually returns. Copy the output directly into your Postman mock server or MSW handler.

Can I download the generated data as a CSV file?

Yes. Select CSV in the format toggle next to the Download button before generating. The tool exports a properly escaped CSV file compatible with Excel, Google Sheets, pandas, and any standard CSV parser. For paginated outputs, only the data rows are exported (the page, total, and perPage wrapper fields are excluded).

How do I generate 10 million rows of fake data?

Type 10000000 in the record count field (or use the quick-select buttons to reach a high count). For outputs above 10,000 records, the file is downloaded automatically without being shown in the preview. Choose JSON or CSV format before clicking Generate. Generation of 100,000 records takes a few seconds; 10 million may take 1–3 minutes depending on your machine.

How do I create sample data for a frontend without a backend?

Generate the dataset with a template that matches your data model, download it as a .json file, and import it into your component as a static fixture. Most frameworks (React, Vue, Svelte) let you import JSON directly: import users from './fixtures/users.json'. This approach is faster than building a mock API and works completely offline.

Can I generate sample CSV data with custom fields?

Yes. Start with any built-in template or use Custom, add and rename fields to match your schema, then toggle the format to CSV before downloading. The resulting file uses your field names as column headers in the first row.

How many records can I generate at once?

Up to 10,000,000 records per generation. For outputs above 10,000 records, the tool auto-downloads the file instead of previewing it in the browser. For very large outputs (100k+), download as JSON or CSV — copying from the browser is not practical at that scale.

Does this tool send my data to a server?

No. Everything runs entirely in your browser using JavaScript. No schema is sent to any server, nothing is stored, and no analytics are collected on your field names or generated output. Refresh the page and everything resets.

How is this different from using Faker.js?

Faker.js is a Node.js library you install as a dev dependency and use in code. This tool is a browser UI that requires zero setup — useful when you need a JSON or CSV file right now without touching your project's dependencies. For programmatic generation inside a seed script or CI pipeline, Faker.js is the right tool. For ad-hoc prototyping, demo data, and Postman fixtures, this generator is faster.

What does the pagination wrapper do?

It wraps the generated array in { data: [...], page: 1, total: N, perPage: 10 } — the response envelope used by most REST APIs (Laravel, Rails, Express pagination middleware). Useful for testing list components that read response.data and display response.total in a pagination control. When exporting as CSV, this wrapper is ignored and only the data rows are exported.

Resources

Related Tools