ForHosting KIT · Data & Files

Mock data generator

Describe the shape of the data you need — a user record, an order history, a thousand product listings — and get back realistic, structurally valid fixtures without hand-writing a single fake row. It's the fastest way to fill a staging database, populate a UI demo, or stress-test a parser with data that looks like the real thing but never was.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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.

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. This matters because the whole point of a fixture is to exercise your validation logic and UI the same way real user input would.

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. Chain it with our format-conversion tools to go straight from a generated JSON payload to a CSV import file or a SQL insert script, so the fixture lands exactly where your seeding process expects it.

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.

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.

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.

FAQ

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.

Is there a free tier for the mock data generator?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

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.

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.

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.

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.

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

POSThttps://api.kit.forhosting.com/data/fake

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, and soon from our app, email and Telegram.

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 &#39;{"text":"…"}'

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({
    "text": "…"
  })
});
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[&#39;KIT_KEY']}"},
    json={
    "text": "…"
},
)
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" => &#39;{"text":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"…"}`)
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

{
  "text": "…"
}

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

Per request$0.002

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.

Read the full KIT documentation →

Run — free