JSON Generator

Related

About the JSON Generator and Mock Test Data

Use Cases

• Frontend development needs stable, repeatable Mock data for rendering components such as user lists, product cards, and order details
• Backend endpoints are not yet ready, so frontend engineers need to fabricate data to integrate the page without waiting for backend responses
• QA writing automated API test cases needs to batch-construct records with varied field values for data-driven test scenarios
• When writing API documentation or Swagger/OpenAPI samples, use the generator to quickly produce well-structured request/response examples
• Preparing large volumes of structured test data before stress and performance testing to validate system stability under high concurrency
• Constructing sample JSON to validate business logic when developing database migration scripts or data cleaning tools
• Teaching and demos: technical blog posts, slide screenshots, and training material that need tidy, well-structured JSON examples
• Frontend form validation and local cache logic development, where boundary values (very small / very large / empty / abnormal types) need to be constructed for testing

How to Use

1. Review the default sample Schema (id / name / email / age / active / createdAt / bio, 7 fields) in the left Schema builder, or click + to add your own custom fields
2. Set a field name and pick from the 13 field types for each row; for Integer, Number, and Paragraph fields, fill in min/max, and for Enum fields, fill in comma-separated candidate values
3. Tick Generate as Array and set a count (1-1000), or untick it to output a single JSON object
4. Click Generate in the top right; the right-hand editor instantly shows formatted JSON results along with field count and record count
5. Click Copy to paste the result into your code or API client, or click Download to save it as a generated.json file

Features

• 13 built-in field types: String / Integer / Number / Boolean / Email / Name / UUID / Date / URL / Phone / Paragraph / Enum / Array ready out of the box, no template syntax to memorize
• Visual field builder: add or remove fields through a graphical UI, set field names and types WYSIWYG, no need to hand-write JSON templates
• Range control for numbers and paragraphs: Integer, Number, and Paragraph types support custom min and max, producing data closer to real business scenarios
• Custom Enum values: enter a comma-separated value list (e.g. admin,user,guest) to generate controlled discrete options
• Single object vs array with one click: toggle the Generate as Array checkbox plus a count input (1-1000) to freely switch between single object and array output
• Sample Schema quick load: built-in 7-field example (id / name / email / age / active / createdAt / bio), click to generate a complete sample instantly
• Syntax-highlighted output panel: a CodeMirror editor on the right shows real-time results with JSON syntax highlighting, line numbers, and read-only browsing
• One-click copy and download: copy generated results to clipboard or download directly as a generated.json file
• Runs entirely in your browser: all field construction and data generation happen locally, zero uploads, safe for sensitive business fields
• Desktop and mobile friendly: split-pane layout on desktop with adjustable panels, mobile automatically switches to input/output tabs for smooth operation

Code Examples

// Put generated.json under /public/mock/users.json
// Then fetch it as Mock data
async function fetchMockUsers() {
  const res = await fetch('/mock/users.json');
  const users = await res.json();
  console.log(`Loaded ${users.length} users`);
  return users;
}

// Or inline directly in code (great for test cases)
const mockUsers = [
  { id: 1, name: 'Jennifer Martinez', email: 'jennifer.martinez382@example.com', age: 42, active: true },
  { id: 2, name: 'Robert Smith', email: 'robert.smith918@test.org', age: 67, active: false }
];

// Or import it as a fixture in Jest / Vitest
import users from './fixtures/users.json';
test('renders user list', () => {
  render(<UserList users={users} />);
  expect(screen.getAllByRole('listitem')).toHaveLength(users.length);
});

# Install: pip install faker
from faker import Faker
import json

fake = Faker('zh_CN')  # Chinese localization

# Generate a single user
def gen_user():
    return {
        "id": fake.random_int(min=1, max=99999),
        "name": fake.name(),
        "email": fake.email(),
        "phone": fake.phone_number(),
        "address": fake.address(),
        "company": fake.company(),
        "created_at": fake.iso8601()
    }

# Generate 100 records and write them to generated.json
users = [gen_user() for _ in range(100)]
with open('generated.json', 'w', encoding='utf-8') as f:
    json.dump(users, f, ensure_ascii=False, indent=2)

print(f"Generated {len(users)} user records")

# Assume generated.json is in the current directory and the target endpoint is POST /api/users
# Bulk seed data
for i in $(seq 1 10); do
  curl -X POST https://api.example.com/users \
    -H "Content-Type: application/json" \
    -d @generated.json | jq '.'
done

# Or extract a single record with jq and POST it
cat generated.json | jq '.[0]' | \
  curl -X POST https://api.example.com/users \
    -H "Content-Type: application/json" \
    -d @-

FAQ

Troubleshooting

Glossary

JSON

JavaScript Object Notation, a lightweight data interchange format built from key-value pairs and arrays, the de facto standard for Web APIs and frontend/backend data transfer.

Mock Data

Fabricated data that simulates real business scenarios, used in frontend development, API integration, and automated testing where no real backend is connected. It must mirror the structure of the real endpoint.

Schema

A definition that describes the structure of data, for example a user contains id, name, and email. In this tool, Schema refers to the field names and types defined in the left field builder.

UUID (v4)

Universally Unique Identifier, a 128-bit string defined by RFC 4122. v4 is random-number based (with 13/8/9/a/b variant bits), virtually never collides, and is commonly used for distributed primary keys.

Field Type

The data type that every field in this tool must specify, which determines what kind of random value is generated for that field. For example, Email generates email-format strings while Integer generates integers.

Enum

A field type that randomly picks one value from a predefined discrete set. For example, defining admin,user,guest gives three options, ideal for roles, statuses, and tier fields.

min / max

Range constraints applied to a field, only effective for Integer, Number, and Paragraph types. When set, random values are generated within the closed interval, avoiding obviously fake boundary values.

Single object vs array output

Two output modes supported by the tool: when Generate as Array is unticked, a single JSON object {} is output (good for single-record API debugging); when ticked with a count, an object array [...] is output (good for bulk data).

RFC 4122

The international standard for UUIDs that defines UUID format, versions (v1-v5), and variant bits. The UUIDs generated by this tool comply with the v4 specification.

CodeMirror

A browser-side code editor component. The right-hand output area of this tool uses CodeMirror to provide JSON syntax highlighting, line numbers, and read-only browsing.

Local Processing

All field construction and data generation runs entirely in the user's browser via JavaScript, never uploaded to any server. It is faster, more private, and safe for sensitive business fields.

Fixture

A sample data file used repeatedly in tests. Generator output can be saved as generated.json and reused as a regression test fixture, ensuring reproducible test results.

Field types and generation rules cheat sheet

The value ranges, typical uses, and samples for all 13 built-in field types:

Common JSON generation scenarios and recommended field combinations

The most common API test data scenarios and recommended field combinations, ready to reference and add:

Privacy & Security

All field construction, random data generation, copy, and download operations in this JSON Generator run entirely locally in your browser via JavaScript. Your defined Schema, generated random data, field names, and counts are never uploaded to any server, nor are they logged, cached, or stored in the cloud. It is safe to use for internal API fields, pre-launch business structures, and sensitive test scenarios with no risk of data leakage.

Authoritative References

• IETFRFC 4122 - UUID specification
• OfficialJSON.org - official JSON specification
• MDNMDN - JSON.parse / JSON.stringify
• LibraryFaker.js - modern fake data library
• LibraryMock.js - frontend Mock data library