JSON Mock Data Generator: Fake JSON with faker.js and json-schema-faker

Generate mock JSON with @faker-js/faker

@faker-js/faker is a TypeScript-first library that supports both ESM and CommonJS and requires Node.js 18+. It provides 60+ modules covering every common data type: people, internet, location, company, commerce, finance, lorem ipsum, dates, UUIDs, and images. Because each faker method call generates a new independent value, the idiomatic pattern for creating arrays of records is Array.from({ length: N } , createRecord) — each invocation of the factory function produces a completely new random object.

import { faker } from '@faker-js/faker'

function createMockUser() {
  return {
    id: faker.string.uuid(),
    name: faker.person.fullName(),
    email: faker.internet.email(),
    phone: faker.phone.number(),
    address: {
      street: faker.location.streetAddress(),
      city: faker.location.city(),
      country: faker.location.country(),
      zip: faker.location.zipCode(),
    },
    company: faker.company.name(),
    avatar: faker.image.avatar(),
    createdAt: faker.date.past({ years: 2 }).toISOString(),
    isActive: faker.datatype.boolean(),
  }
}

// Generate 1000 mock users
const users = Array.from({ length: 1000 }, createMockUser)
console.log(JSON.stringify(users, null, 2))

Array.from({ length: 1000 } , createMockUser) is the idiomatic pattern — each call creates a new random record. The result is a 1000-element array where every object has a unique UUID, realistic name, valid-format email, and a nested address object. Paste the output into Jsonic's JSON Formatter to validate and explore the structure. For type safety, add a return type annotation: function createMockUser(): User { ... } where User is inferred from your Zod schema or TypeScript interface.

Seeded random data for reproducible tests

faker.seed(number) fixes faker's random number generator to a deterministic state. Every subsequent faker method call in that process produces the same value in the same order — making it safe to use generated data as snapshot test fixtures. Without a seed, faker generates different values on every run, which causes snapshot tests to fail non-deterministically. Seeding solves this by making the randomness reproducible.

import { faker } from '@faker-js/faker'

faker.seed(12345)

// Always produces the same value — safe for snapshot tests
const user = {
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
}
// { id: "...", name: "...", email: "..." } — identical every time seed(12345) is used

Use cases for seeded generation include Jest snapshot tests (where the fixture must match exactly across CI runs), reproducible CI test fixtures that need to be committed to version control, and debugging — when a test fails with a specific seed you can reproduce the exact data locally. To isolate seed state between test cases, call faker.seed(testIndex) at the start of each test so they don't share the same RNG sequence. For parallel test runners, create a separate faker instance per worker: new faker.Faker({ locale: [en] }) with its own .seed() call.

Generate mock JSON from a JSON Schema with json-schema-faker

json-schema-faker takes a JSON Schema definition and generates mock data that conforms to it. This is useful when you already have a JSON Schema for your API or data model and don't want to write a separate faker template that could drift out of sync. Install with npm install json-schema-faker. It supports JSON Schema drafts 04, 06, 07, 2019-09, and 2020-12, and uses @faker-js/faker internally to generate realistic values for named formats like email, date-time, and uuid. For schemas with $ref references, use jsf.resolve(schema) (returns a Promise) instead of jsf.generate(schema).

import jsf from 'json-schema-faker'

const schema = {
  type: 'object',
  properties: {
    id: { type: 'integer', minimum: 1, maximum: 9999 },
    username: { type: 'string', minLength: 3, maxLength: 20 },
    email: { type: 'string', format: 'email' },
    score: { type: 'number', minimum: 0, maximum: 100 },
    tags: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 5 },
  },
  required: ['id', 'username', 'email'],
}

// Generate a single record
const record = jsf.generate(schema)

// Generate 50 records
const records = Array.from({ length: 50 }, () => jsf.generate(schema))
console.log(JSON.stringify(records, null, 2))

json-schema-faker respects all schema constraints: minimum, maximum, minLength, maxLength, minItems, maxItems, enum, const, and required. Generated values for format: "email" are realistic email addresses, not random strings. For writing schemas that json-schema-faker can use, see our JSON Schema guide and our guide to validate JSON Schema in JavaScript with Ajv.

Vanilla JavaScript mock data generator (no dependencies)

For simple use cases where installing a library is not practical — browser scripts, restricted environments, or minimal projects — Math.random() combined with a few helper functions covers most needs. This approach produces less realistic data (names come from a fixed list rather than locale-aware generation) but has zero dependencies and works in any JavaScript environment including browsers and older Node.js versions.

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min
}

function randomItem(arr) {
  return arr[Math.floor(Math.random() * arr.length)]
}

const statuses = ['active', 'inactive', 'pending']
const domains = ['gmail.com', 'yahoo.com', 'outlook.com']

function generateRecord(i) {
  const firstName = randomItem(['Alice', 'Bob', 'Carol', 'David', 'Eve'])
  const lastName = randomItem(['Smith', 'Jones', 'Lee', 'Brown', 'White'])
  return {
    id: i + 1,
    name: `${firstName} ${lastName}`,
    email: `${firstName.toLowerCase()}.${randomInt(1, 999)}@${randomItem(domains)}`,
    age: randomInt(18, 65),
    status: randomItem(statuses),
    createdAt: new Date(Date.now() - randomInt(0, 365 * 24 * 60 * 60 * 1000)).toISOString(),
  }
}

const dataset = Array.from({ length: 100 }, (_, i) => generateRecord(i))
console.log(JSON.stringify(dataset, null, 2))

This approach produces less realistic data but has zero dependencies and works in any JS environment including browsers. For a UUID without dependencies, use the Web Crypto API: crypto.randomUUID() is available in all modern browsers and Node.js 14.17+. To extend this pattern with more realistic data, swap the fixed name arrays for larger datasets loaded from a JSON file, or add locale-specific name lists as plain arrays.

Online JSON mock data generator tools compared

Several online tools generate mock JSON without writing code. Each has different trade-offs around free tier limits, supported formats, and input method. Programmatic approaches (faker.js, json-schema-faker) offer unlimited records and integrate into automated workflows; GUI tools like Mockaroo are faster for one-time manual downloads. Use Jsonic's JSON Formatter to validate any generated output before using it in your tests.

All programmatic approaches run in Node.js; faker.js also works in modern browsers via ESM imports. Mockaroo and JSON Generator are browser-only GUI tools with no programmatic API in the free tier. For automated test pipelines, @faker-js/faker is the clear choice — it integrates directly into Jest, Vitest, or any Node.js test runner and supports seeded generation for reproducible fixtures.

Generate nested JSON mock data

Real API responses often have nested arrays and objects — pagination wrappers, embedded reviews, related entities. faker.js handles this naturally because each faker call is independent: you can nest Array.from() calls to generate sub-arrays of variable length. The example below simulates a paginated API response with products, each containing a variable number of embedded reviews.

import { faker } from '@faker-js/faker'

function generateApiResponse(page = 1, perPage = 10) {
  return {
    page,
    perPage,
    total: 500,
    data: Array.from({ length: perPage }, () => ({
      id: faker.string.uuid(),
      product: faker.commerce.productName(),
      price: parseFloat(faker.commerce.price()),
      category: faker.commerce.department(),
      inStock: faker.datatype.boolean(),
      reviews: Array.from({ length: faker.number.int({ min: 0, max: 5 }) }, () => ({
        rating: faker.number.int({ min: 1, max: 5 }),
        comment: faker.lorem.sentence(),
        reviewer: faker.person.firstName(),
      })),
    })),
  }
}

console.log(JSON.stringify(generateApiResponse(1, 5), null, 2))

The key detail is faker.number.int({ min: 0, max: 5 }) as the length argument to the inner Array.from() — this gives each product a random number of reviews between 0 and 5, mirroring real API variability. Use Jsonic's JSON Validator to confirm the output is well-formed before wiring it into your test suite. For validating the structure against a schema, see our guide on validate JSON Schema in JavaScript with Ajv.

Frequently asked questions