Documentation

Dummy JSON Generator is a free, browser-based tool for creating realistic fake JSON, CSV, and SQL test data — instantly, with no signup or server involved.

Quick start

Go from zero to generated data in under 60 seconds:

1. Open the tool — dummyjsongenerator.com/json-generator. No account required.
2. Add fields — click Add Field and pick a type from the dropdown. Rename the field to match your schema.
3. Set record count — type a number or drag the slider. Range: 1 to 1,000,000.
4. Choose format — toggle between JSON, CSV, or SQL.
5. Generate — click the Generate button. Copy to clipboard or download as a file.

The interface

The tool is divided into three panels:

• Schema builder (left) — add, rename, reorder, and delete fields. Drag handles let you reorder fields by dragging.
• Settings bar (top) — set record count, output format, indentation, and table name (SQL only).
• Output panel (right) — live preview of the generated output. Copy to clipboard or download from here.

Personal fields

Fields relating to a person's identity and contact information.

Example output

{
  "id": "a3f8b2c1-4e5d-6f7a-8b9c-0d1e2f3a4b5c",
  "firstName": "Ayesha",
  "lastName": "Rahman",
  "email": "ayesha.rahman94@gmail.com",
  "phone": "+1-555-234-8821",
  "age": 27,
  "avatar": "https://i.pravatar.cc/150?img=47"
}

Location fields

Geographic data including addresses, coordinates, and postal codes.

Technical / ID fields

Identifiers and low-level technical values used in application data.

Number fields

Numeric field types with configurable ranges.

Configuring ranges

Click the settings icon next to an integer or float field to set min/max bounds. The range is inclusive on both ends.

Date & time fields

All date/time fields output ISO 8601 formatted values unless otherwise noted.

Internet & commerce fields

Text fields

Free-text content at varying lengths.

Enum (custom list)

The Enum field type lets you provide your own list of values. Each record gets one value from the list, selected at random with equal probability.

Configuration

1. Add a field and select Enum as the type
2. In the values input, enter your options separated by commas
3. Each option is trimmed of whitespace before use

Field name: status
Field type: Enum
Values:     draft, published, archived, deleted

[
  { "status": "published" },
  { "status": "draft" },
  { "status": "archived" }
]

JSON output

The default output format. Each record is an object inside a top-level array.

[
  {
    "id": "a3f8b2c1-4e5d-6f7a-8b9c-0d1e2f3a4b5c",
    "fullName": "Ayesha Rahman",
    "email": "ayesha.rahman94@gmail.com",
    "city": "Lahore",
    "status": "active",
    "createdAt": "2024-08-14T09:33:21.000Z"
  },
  {
    "id": "b7c3d4e5-5f6a-7b8c-9d0e-1f2a3b4c5d6e",
    "fullName": "James O'Brien",
    "email": "jobrien_dev@outlook.com",
    "city": "Dublin",
    "status": "inactive",
    "createdAt": "2025-01-02T16:47:05.000Z"
  }
]

Indentation options

• 2 spaces (default) — most readable for development
• 4 spaces — matches many style guides
• Compact — minified, no whitespace — smallest file size

CSV output

Comma-separated values with a header row. Ideal for spreadsheets, Postman data-driven testing, and database imports via COPY or LOAD DATA INFILE.

id,fullName,email,city,status,createdAt
a3f8b2c1,Ayesha Rahman,ayesha@example.com,Lahore,active,2024-08-14T09:33:21.000Z
b7c3d4e5,James O'Brien,james@example.com,Dublin,inactive,2025-01-02T16:47:05.000Z

Escaping rules

• String values containing commas or double quotes are automatically wrapped in double quotes
• Internal double quotes are escaped as "" (RFC 4180 standard)
• Newlines within values are escaped as \n

Importing CSV into databases

-- Fastest import method — 10-50x faster than INSERT
\COPY users (id, full_name, email, city, status, created_at)
FROM '/path/to/data.csv'
CSV HEADER;

LOAD DATA INFILE '/path/to/data.csv'
INTO TABLE users
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
IGNORE 1 ROWS;

SQL output

Generates batched INSERT INTO statements ready to execute against any SQL database.

INSERT INTO records (id, fullName, email, city, status, createdAt) VALUES
('a3f8b2c1', 'Ayesha Rahman', 'ayesha@example.com', 'Lahore', 'active', '2024-08-14 09:33:21'),
('b7c3d4e5', 'James O''Brien', 'james@example.com', 'Dublin', 'inactive', '2025-01-02 16:47:05');

Notes

• Statements are batched at 1,000 rows per INSERT — much faster than one INSERT per row
• The default table name is records — change it in the SQL settings panel before generating
• Single quotes inside string values are escaped as '' (standard SQL escaping)
• Works with PostgreSQL, MySQL, MariaDB, SQLite, and SQL Server

Changing the table name

If you've already downloaded the file and need to rename the table:

# Linux / macOS
sed -i 's/INSERT INTO records/INSERT INTO users/g' generated-data.sql

# Windows PowerShell
(Get-Content generated-data.sql) -replace 'INSERT INTO records', 'INSERT INTO users' | Set-Content generated-data.sql

Schema saving

Save your field configuration as a named schema and reload it in any future session.

Saving a schema

1. Configure your fields in the schema builder
2. Click the Save Schema button in the top bar
3. Enter a descriptive name (e.g., "E-commerce Order", "User Analytics Event")
4. Click Save

Loading a schema

1. Click Load Schema
2. Select from your saved schemas in the dropdown
3. Your field configuration is restored instantly

Record counts & performance

Generation happens entirely in your browser using JavaScript. Performance depends on record count, field count, and field complexity.

Configuration options

JSON indent

Controls whitespace in JSON output. Options: 2 spaces, 4 spaces, compact.

Use compact to minimize file size when generating large datasets for load testing.

SQL table name

The table name used in INSERT INTO statements. Default: records. Change this to match your actual table name before generating.

Field names

Every field name is editable. Click the field name in the schema builder to rename it. Names are used exactly as-is in the output — including capitalization and underscores.

Examples: fullName, full_name, FullName — all produce different key names in the output.

Use case: API testing

Generate a JSON fixture file and use it as a mock API response or as data for a Postman collection run.

With Postman (data-driven testing)

1. Generate your data as CSV with fields matching your API request body
2. In Postman: Collection → Run Collection → upload your CSV as the data file
3. Reference fields in your request body as {{email}}, {{firstName}}, etc.
4. Postman runs one request per CSV row

With MSW (Mock Service Worker)

import { http, HttpResponse } from 'msw';
import users from './fixtures/users.json';

export const handlers = [
  http.get('/api/users', () => {
    return HttpResponse.json(users);
  }),
];

Use case: Database seeding

Generate a seed dataset and commit it to your repository so every developer runs the same data.

With Prisma

// prisma/seed.ts
import { PrismaClient } from '@prisma/client';
import users from '../seed-data/users.json';

const prisma = new PrismaClient();

async function main() {
  await prisma.user.createMany({ data: users, skipDuplicates: true });
  console.log(`Seeded ${users.length} users.`);
}

main().finally(() => prisma.$disconnect());

"prisma": {
  "seed": "ts-node prisma/seed.ts"
}

Run with: npx prisma db seed

Use case: Load testing

Generate up to 1,000,000 records for performance benchmarking and stress testing.

With k6

import http from 'k6/http';
import { check } from 'k6';
import data from './load-test-data.json';

export const options = { vus: 100, duration: '30s' };

export default function () {
  const record = data[Math.floor(Math.random() * data.length)];
  const res = http.post('https://your-api.com/events', JSON.stringify(record), {
    headers: { 'Content-Type': 'application/json' },
  });
  check(res, { 'status 200': (r) => r.status === 200 });
}

Use case: Frontend development

Build your UI with realistic data before the backend API is ready.

React — local import

import users from '@/data/users.json';

export default function UserList() {
  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>
          <img src={user.avatar} alt={user.fullName} />
          <span>{user.fullName}</span>
        </li>
      ))}
    </ul>
  );
}

Next.js — mock API route

// app/api/users/route.ts
import { NextResponse } from 'next/server';
import users from '@/data/users.json';

export async function GET() {
  return NextResponse.json(users);
}

Browser compatibility

JavaScript must be enabled. No extensions or plugins required.

Privacy & security

All data generation happens entirely in your browser using JavaScript.

• No server-side processing — your schema configuration and generated data never leave your device
• No logging — we don't log what field types you use or what data you generate
• No analytics on your data — only standard page-level analytics (pageviews) are collected
• Safe for sensitive schemas — if your schema represents a sensitive data model (healthcare, finance), there's no risk of exposure

Limits

FAQ

Can I use generated data in production?

No. Generated data is invented — it refers to no real people or entities. Do not use it in production systems, for any decision-making, or in any context where real data is expected.

Is there a REST API?

Not currently. The tool is fully client-side. For programmatic generation in your codebase, use Faker.js (JavaScript/TypeScript) or Datafaker (Java/Kotlin).

Can I generate nested JSON objects?

Flat objects only in the current version. Nested object and array field support is planned for v3.0.

Why does generation slow down at very large record counts?

JavaScript is single-threaded. At 1M records, memory pressure and GC pauses are noticeable. Keeping your field count low and avoiding text-heavy fields (paragraph, lorem, userAgent) significantly improves speed at scale.

My browser ran out of memory generating 1M records — what do I do?

Reduce record count or field count. For very large datasets (>500K records), use a programmatic approach with Faker.js and a streaming file writer — see our load testing guide.

How do I report a bug or request a feature?

Open an issue on GitHub or email hello@dummyjsongenerator.com.

Changelog

v2.0 — June 2026

• Full rebuild with Nuxt 3 / Vue.js
• New dark design system
• SQL export format
• Schema save / load
• Record limit raised from 100K to 1,000,000
• Enum field type
• Compact JSON indentation option

v1.0 — 2025

• Initial release
• JSON and CSV export
• 20 field types