Mock JSON Data Generator

Generate Realistic Mock JSON Data

Once you have a shape for your data — a JSON Schema from the Schema Generator, or just a sample response — the next thing you usually need is a batch of realistic-looking fake records to populate a UI, seed a database, or write tests against. This tool generates that data for you: paste a JSON Schema or a sample JSON object, choose how many rows you want, and get back properly shaped fake data with names, emails, IDs, and other fields that actually look real — not just repeated placeholder text.

How It Works

• Paste a JSON Schema or a sample JSON payload into the left editor, or click Sample to try an example schema.
• Set the row count (1–500) and click Generate — each row is generated fresh from the same shape. Changing the row count regenerates at once, and the output is always an array, even for one row.
• Field names drive realism: a field called email gets a real-looking email, firstName gets a first name, createdAt gets a timestamp, and so on — not just a random string.
• Switch to CSV if you need the output in a spreadsheet-friendly format instead of JSON.
• Copy or download the result directly into your project or test fixtures (mock-data.json or mock-data.csv).

Schema Input or Sample Input — Both Work

You can paste either a full JSON Schema (with type, properties, and format keywords — exactly what the JSON Schema Generator produces) or just a plain sample JSON object or array. When you paste a schema, declared format values like email, uuid, and date-time are honored directly. When you paste a sample, the tool infers the shape and uses each field's name and original type to pick a realistic generator — so a numeric id stays a number instead of turning into something else.

Two details are worth knowing. With a sample, only the shape and the types are used: your example values are never copied, so a sample "version": "1.0" comes back as a random word and "page": 1 as a random integer. If a field must keep a fixed value, use a schema with enum, which picks from the list (a one-item list gives that item every time). And a top-level array is treated as a list of one example: the first element is the template for every row.

How a Field Gets Its Value

For each field the tool checks, in this order: a format keyword from the schema, then the field name against a list of patterns, and finally the type. The name check ignores case and looks for the pattern anywhere in the name, and the first match wins. Every row of the table below was run through the live tool, 300 values per field, and the values matched the description each time.

Surprises from Name Matching

Because the first matching pattern wins and the match is a substring match, a few names behave in ways you might not expect. A field called statement contains state and gets a state or province name. A field called ipAddress (or ip_address) contains address, and the address rule comes before the IP rule, so it receives a street address; name the field plain ip to get an IP-style value. lng is not recognised as a longitude (use lon, long or longitude), so it falls back to a number from 0 to 1000. A field named age always gets 18–90, even if your schema says minimum: 0 and maximum: 5. When a field comes out wrong, rename it or give it a format, or use enum to control the values exactly.

A Worked Example You Can Reproduce

Random data cannot be shown as exact output, but constants can. This schema gives status and plan a single-value enum, leaves misc without a type, and nests a country. We pasted it into the live tool with 2 rows and ran it as JSON and as CSV:

{
  "type": "object",
  "properties": {
    "status": {
      "enum": [
        "active"
      ]
    },
    "plan": {
      "enum": [
        "free"
      ]
    },
    "misc": {},
    "address": {
      "type": "object",
      "properties": {
        "country": {
          "enum": [
            "Norway"
          ]
        }
      }
    }
  }
}

[
  {
    "status": "active",
    "plan": "free",
    "misc": null,
    "address": {
      "country": "Norway"
    }
  },
  {
    "status": "active",
    "plan": "free",
    "misc": null,
    "address": {
      "country": "Norway"
    }
  }
]

status,plan,misc,address.country
active,free,,Norway
active,free,,Norway

Notice three things. The key order follows the schema. A field with no usable type, misc, becomes null in JSON and an empty cell in CSV. And in CSV the nested address.country becomes a column called address.country: nested objects are flattened with dot notation. Arrays do not become columns; each array is written into a single cell as JSON text with its quotes doubled, so a row with "tags":["a"] and a note containing a comma still opens as one record in a spreadsheet. For a different input the header line was id,user.name,user.geo.lat,tags,note.

Arrays, Nesting and Row Counts

Each array in a schema or a sample gets one to three items per row, chosen at random, and each item is generated from the schema's items (or from the sample's first element). Objects nest as deeply as your shape does. The row count is limited to 500 per batch: a larger number is lowered to 500 with a message, and an empty or zero value becomes 1. For more data, generate several batches and merge them, for example with the JSON to CSV converter or a script.

Building a Realistic API Response

Start from a real response if you have one. Paste a single item, not the whole envelope: the tool repeats whatever you paste, so an envelope such as {"data": [...], "page": 1} would be repeated in every row with its own random array. Generate rows for the item, then wrap the array in your envelope by hand ({"data": <rows>, "total": 20}). If you only have a few examples, the JSON Schema Generator can merge several samples into a schema first, with nullable and optional fields described. Then use enum to pin the status values you care about, and name the fields so the generator recognises them: createdAt for timestamps, email for contact addresses, price for money. Finally, run the output through the JSON formatter or the JSONPath tester to check the paths your front-end code will use.

Using the Data with Other Tools

• Round trip: generate rows, then paste the array into the JSON Schema Generator, which merges all rows into one schema, to confirm the schema describes what you produce.
• Compare: use compare-json to see which keys changed between two versions of a fixture.
• Convert: turn the JSON into CSV or Excel with the JSON to CSV converter or the JSON to Excel converter if you need more control over delimiters, nested values and sheets than the built-in CSV.
• Validate: the JSON Schema validator can check rows against your schema, but remember the limits below: the generator follows the shape, not the constraints.

Limits of Fake Data

• Constraints are ignored. required, minimum, maximum, minLength, pattern, uniqueItems, anyOf, oneOf, allOf and $ref have no effect. A property that is defined with anyOf or through $ref or $defs (the Schema Generator can write these) comes out as null. Where type is a list, such as ["string","null"], only the first type is used.
• It is random every time. There is no seed, so you cannot reproduce a batch. Save the output if a test needs it again. The values come from Math.random(), which is fine for fixtures and never suitable for secrets or tokens. UUIDs use crypto.randomUUID() where the browser has it.
• The pools are small. There are 36 first names, 30 last names and 8 email domains, so large batches will repeat names, and an email can repeat. UUID-based IDs are for practical purposes unique.
• It is not realistic everywhere. Phone numbers are in a US format, addresses are US-style, text is Latin placeholder text, and dates fall in the last three years. There is no locale option.
• No relationships. Two fields called userId in different places are unrelated, and nothing links a child row to a parent.
• Do not email the addresses. The names and domains are invented, but the combinations (for example at gmail.com) can coincide with real people.

Privacy

All data generation happens entirely in your browser using JavaScript. Your schema or sample data — and the fake data generated from it — never leaves your device.

Related Tools

• JSON Schema generator: generate a schema to drive the mock data.
• JSON Schema validator: validate the generated data against a schema.
• JSON to code generator: generate classes and types for Java, C#, PHP, TypeScript, Python and Go.
• JSON to CSV converter: flatten nested JSON into CSV with your choice of delimiter.
• JSON to Excel converter: write generated rows to an .xlsx workbook.
• UUID generator: generate random UUID v4 identifiers, in bulk.
• Compare two JSON documents: see added, removed and changed keys, with options to ignore array order and chosen keys.
• JSONPath tester: check the paths your code will use on the generated data.
• JSON formatter and fixer: validate, format and repair JSON before you use it here.
• all JSON tools: every free tool listed on one page.

Last updated: October 2026