Mock data generator
Describe the columns you need and get rows that look real but belong to nobody: in the example, 3 rows such as Ana García, ana0@example.com, 2023-11-14, with an amount for each. No customer data is ever involved. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
realistic test fixtures, free
Why real data and hand-made samples both fall short
Copying production data into a development or demo environment is a privacy problem waiting to happen. Hand-made samples are hardly better: they are usually five records copied and pasted with the name changed, and they never look like what real people type. What a team actually needs is data that is shaped like the real thing without being real. That is what this generator provides: each row has a plausible name, an address that clearly belongs to nobody, a date and a figure, so a screen, a report or an import can be checked without exposing anyone.
How to describe the rows you need
List the columns you want and, for each one, the kind of value it should contain: a name, an email address, a phone number, a date, an identifier, a whole number, a word or an amount. Then say how many rows to create. In the example, four columns and a count of 3 produce Ana García, Luis Díaz and Marta Cruz, with dates that follow each other day by day starting on 2023-11-14 and amounts of 0, 13.37 and 26.74. Use it to fill a staging database, to give a product demo believable customers instead of the same three typed-in rows, or to check how a form handles a full table.
Why real data is the wrong tool for testing
Using production data in a development or QA environment is a privacy problem waiting to happen, and hand-rolled sample data is worse: it's usually five records copy-pasted with the name changed, which never surfaces the edge cases — a name with an apostrophe, an address with no state field, an email with a plus sign — that break parsers and forms in production. What every team actually needs is data that's structurally realistic without being real.
What you can do with it
Seeding staging databases
Generate thousands of realistic user and order records overnight to keep a staging environment populated without ever touching production data.
Frontend and demo environments
Fill a dashboard or product demo with plausible customer names, dates and figures instead of the same three hardcoded rows every prospect sees.
Load and parser testing
Produce a large batch of records with edge-case values — long names, unusual characters, boundary numbers — to confirm your validation logic holds up.
FAQ
Is there a free tier for the mock data generator?
The tool above runs free in your browser. No subscription, no tokens, and a failed task is never charged.
Can I control constraints, like a minimum age or a specific date range?
Yes, numeric and date fields accept min and max bounds, and you can restrict a field to a fixed set of values for things like status or category.
Could the generated data accidentally match a real person?
It's synthetic and drawn from generic naming and formatting patterns, not from any real individual's records, though as with any generated text a coincidental resemblance to a real name is possible.
What kinds of values can the generator create?
Names, email addresses, phone numbers, dates, unique identifiers, whole numbers, amounts and words, among others. You give each column a name of your choice and pick the kind of value it should hold, as in the example with name, email, date and amount columns.
Do the generated email addresses reach real inboxes?
No. Every generated address ends in example.com, as in ana0@example.com, a domain set aside for examples. A welcome message or a password reset sent during a trial run therefore never lands in a real customer's mailbox.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/data/fake \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"schema":{"name":"name","email":"email"}}'const res = await fetch("https://api.kit.forhosting.com/data/fake", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"schema": {
"name": "name",
"email": "email"
}
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/data/fake",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"schema": {
"name": "name",
"email": "email"
}
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/data/fake", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"schema":{"name":"name","email":"email"}}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"schema":{"name":"name","email":"email"}}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/data/fake", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"schema": {
"name": "name",
"email": "email"
}
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "data.fake",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_mb | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
How the schema-to-fixtures step works
POST /data/fake takes a schema describing the fields you want — types like name, email, address, uuid, date, integer with a range, or a nested object — along with a record count, and generates that many rows that respect the types and any constraints you set, like a minimum and maximum for numeric fields or a fixed set of enum values for a status column. The task_id returned lets you fetch a JSON, CSV or SQL-insert result once generation finishes.
Realistic, not random garbage
There's a meaningful difference between random strings and mock data that behaves like the real world: a generated address includes a street, city and postal code that are internally consistent in format; a generated name draws from actual naming patterns rather than random character strings; a generated phone number matches a plausible format.
Fitting it into a test or demo pipeline
Because it's async, you can trigger this endpoint as a setup step in a CI pipeline before integration tests run, or from a seed script that populates a fresh staging database every night.
Where mock data generation comes from
The practice traces back to unit testing culture and, more specifically, to libraries like Faker, which popularized the idea of type-aware random generation over two decades ago; our endpoint follows that same principle — respect the type, respect the constraints, but keep the value unpredictable — while removing the need to install, configure and maintain a generation library inside every service that needs sample data.
Integration use cases
API contract testing
Generate request and response fixtures that match your schema exactly, so integration tests exercise the real shape of the data your API expects.
Technical questions
How do I generate fake data with the API?
POST a schema describing your fields and desired record count to /data/fake; you get a task_id and the generated fixtures arrive via webhook or a signed link in JSON, CSV or SQL format.
What field types are supported?
Common types like name, email, address, phone, uuid, date, integer and float with ranges, boolean, and enum values from a fixed list, plus nested objects for more complex records.
How many records can I generate in one request?
You set the record count in the schema; larger counts simply take longer to process, and the $0.002 price is per request regardless of how many rows it produces.
Is the generated data actually random, or does it repeat?
Each request produces a fresh, independently generated set of records; nothing is cached or reused between requests.
What output formats are available?
JSON, CSV and SQL insert statements, so the fixture can drop straight into a database seed script or a frontend mock.