Free Mock Data Generator — Unlimited SQL, JSON, CSV
Generate realistic test data with zero limits. Define your schema manually, import from a
CREATE TABLE statement, or pick a preset — then download up to 100,000+ rows instantly.
Everything runs in your browser — no data leaves your device.
Schema Builder
Preview
Why ToolShelf Mock Data Generator?
Most mock data tools limit free usage or require server uploads. ToolShelf runs 100% in your browser — no row limits, no account, no privacy concerns.
How We Compare to Other Mock Data Tools
| Feature | ToolShelf | Mockaroo | Others |
|---|---|---|---|
| Row Limit (Free) | Unlimited | 1,000 | Varies (100–5,000) |
| Signup Required | No | Yes | Often |
| Data Privacy | 100% Local | Server-side | Server-side |
| Output Formats | JSON, CSV, SQL | JSON, CSV, SQL, XML | Varies |
| Speed (100k rows) | ~3 seconds | N/A (paid tier) | N/A |
| Offline Support | Yes | No | No |
What is Mock Data?
Mock data (also called fake data, dummy data, or seed data) is synthetically generated information that mimics real-world data structures. Developers use it to populate databases for testing, build UI prototypes, conduct load testing, and validate data pipelines — all without risking real user information.
Common Use Cases
- Database Seeding: Populate development and staging databases with realistic test records
- API Prototyping: Generate sample payloads for endpoint testing before real data exists
- Load Testing: Produce thousands of rows to stress-test queries and indexes
- UI Development: Create realistic data for frontend component development
- Data Migration Testing: Verify ETL pipelines with large sample datasets
- Demo Environments: Fill demo apps with believable data for presentations
Supported Data Types
Names
Full names, first names, and last names from diverse locales using Faker.js data sets.
Emails
Realistic email addresses with common providers and realistic username patterns.
Phone Numbers
Properly formatted phone numbers with realistic area codes and prefixes.
Dates
ISO dates, Unix timestamps, and custom format dates across realistic ranges.
UUIDs
Universally unique identifiers for primary keys and reference IDs.
Addresses
Cities, countries, street addresses, zip codes, and geographic coordinates.
Frequently Asked Questions
Is there really no row limit?
Yes. Since all data is generated in your browser using JavaScript, there are no server costs and therefore no artificial limits. We recommend staying under 100,000 rows for a smooth experience, but the tool won't stop you.
Is my data private?
100% private. No data is ever sent to any server. The mock data is generated entirely in your browser using the Faker.js library. ToolShelf doesn't even see what you generate.
What formats are supported?
Currently JSON (array of objects), CSV (with header row), and SQL (INSERT INTO statements). More formats may be added based on user feedback.
Can I customize the field types?
Yes. Use the Schema Builder to define any number of fields, each with a chosen data type. Some types have additional options like date format or number range.
Can I import a schema from SQL?
Yes! Click the Import SQL button in the Schema Builder and paste any
CREATE TABLE statement. The parser supports MySQL, PostgreSQL, SQLite,
and SQL Server DDL syntax. Column types are automatically mapped to the closest Faker
data type so you get realistic test data that matches your production schema.
How does SQL schema import work?
The parser extracts column names and SQL data types from your DDL statement, then uses
a combination of type-based and name-based heuristics to select the best Faker generator.
For example, a VARCHAR column named "email" maps to the Email generator,
while a TIMESTAMP column becomes a DateTime field. You can review and
adjust the mapping before applying.
What SQL dialects are supported for import?
The parser handles standard ANSI SQL, MySQL (backtick-quoted identifiers, AUTO_INCREMENT), PostgreSQL (SERIAL, IDENTITY, quoted identifiers), SQLite (AUTOINCREMENT, flexible types), and SQL Server (bracket-quoted identifiers, IDENTITY). Table constraints like PRIMARY KEY, FOREIGN KEY, and UNIQUE are skipped — only column definitions are extracted.
Is this a good alternative to Mockaroo?
ToolShelf is designed as a free, unlimited alternative to Mockaroo. While Mockaroo limits free users to 1,000 rows and requires signup, ToolShelf lets you generate up to 100,000 rows with no account, no limits, and complete privacy — all processing runs in your browser. Plus, the SQL import feature lets you generate test data directly from your database schema.
Does the tool work without an internet connection?
After the initial page load (which caches the Faker.js library), the tool works completely offline. All data generation happens in your browser's JavaScript engine, so you can generate mock data even without internet access — perfect for air-gapped development environments.
How fast is mock data generation?
Typical performance: 1,000 rows generate instantly, 10,000 rows in under a second, and 100,000 rows in roughly 3–5 seconds depending on your device. For very large datasets, generation runs in chunks to keep the browser responsive.
Can I generate unique values for each row?
Fields like UUID, Email, and ID (auto-increment) automatically produce unique values. For other types like Name or City, values are randomly generated and may occasionally repeat — similar to real-world data distribution.
What is Faker.js and why does this tool use it?
Faker.js is the most popular open-source library for generating realistic fake data. It produces locale-aware names, addresses, phone numbers, and more. ToolShelf loads Faker.js directly in your browser, giving you the same data quality used by thousands of production test suites worldwide.
Can I generate mock data for multiple related tables?
Currently, each generation session produces data for a single table. For related tables, generate each table separately using matching ID ranges. For example, generate a "users" table with IDs 1–1000, then an "orders" table with user_id as an Integer (range 1–1000) to create realistic referential data.
How to Generate Mock Data for Your Database
Follow these steps to create realistic test data for any SQL database, REST API, or frontend prototype:
- Define your schema — Use the Schema Builder to add columns with names and data types, or import directly from a
CREATE TABLEstatement. - Choose your output format — Select JSON for API testing, CSV for spreadsheets and data imports, or SQL for direct database seeding with
INSERT INTOstatements. - Set the row count — Generate anywhere from 1 to 100,000 rows. Large datasets are generated in chunks to keep the browser responsive.
- Preview and download — Click Preview to inspect the first 10 rows, then Generate & Download for the full dataset as a file.
Generate SQL INSERT Statements for Testing
Need to populate a development database quickly? ToolShelf generates ready-to-use
INSERT INTO statements that you can run directly in MySQL, PostgreSQL, or any
SQL-compatible database. Set the table name, define your columns, and download thousands of
realistic INSERT statements in seconds.
The SQL output properly escapes string values, handles NULLs, and formats booleans correctly for your target database. Unlike other tools that charge for SQL output, ToolShelf provides this completely free.
Import CREATE TABLE to Generate Test Data
The SQL Schema Import feature parses your existing CREATE TABLE DDL and automatically
builds the corresponding mock data schema. It understands common SQL types like VARCHAR,
INT, TIMESTAMP, BOOLEAN, UUID, and more.
Smart column-name heuristics ensure that a column named "email" gets realistic email addresses,
"city" gets real city names, and "phone" gets properly formatted phone numbers — even if the
SQL type is just VARCHAR(255).
Why Developers Choose ToolShelf
Unlimited Generation
No row limits, no paid tiers. Generate as much test data as your browser can handle.
100% Private
All data generation runs locally. Nothing is uploaded, tracked, or stored on any server.
Blazing Fast
Generate 10,000 rows in under a second. Powered by Faker.js optimized for browser use.
Works Offline
After initial load, the tool works without an internet connection.
Mock Data Glossary for Developers
- Mock Data (Fake Data): Synthetically generated information that mimics real-world data structures. Used in development, testing, and prototyping without exposing real user information.
- Seed Data: Initial data loaded into a database to establish a baseline for testing or development. Mock data generators are the most common way to create seed datasets.
- Faker.js: The most widely-used open-source JavaScript library for generating realistic fake data — names, emails, addresses, dates, and more — in multiple locales.
- DDL (Data Definition Language): SQL statements like
CREATE TABLEthat define database schema structure. ToolShelf can parse DDL to auto-generate mock data schemas. - Schema: The structure of a database table or data object — column names, data types, constraints, and relationships. The Schema Builder lets you define or import this structure.
- Test Fixtures: Pre-defined data sets used to establish a repeatable test environment. Mock data generators create fixtures dynamically instead of maintaining static fixture files.
- INSERT Statement: A SQL command that adds new rows to a database table. ToolShelf generates ready-to-run INSERT statements for MySQL, PostgreSQL, SQLite, and other SQL databases.
- CSV (Comma-Separated Values): A plain-text format where each line is a data record and fields are separated by commas. Widely supported by databases, spreadsheets, and ETL tools.
Mock Data Best Practices for Developers
- Match your production schema: Use the SQL Import feature to copy your exact
CREATE TABLEstructure. This ensures your test data fits your constraints and foreign keys. - Use realistic value ranges: Set Integer and Float min/max values that mirror production data. An age column should use 18–90, not 0–1,000,000.
- Test edge cases first: Generate small datasets (5–10 rows) to verify formatting and column types, then scale up to thousands for load testing and performance benchmarks.
- Keep column names semantic: The tool uses column name heuristics to assign Faker types automatically. Naming a column "email" instead of "e" gets you realistic email addresses.
- Mix output formats: Generate the same schema in JSON, CSV, and SQL to test all your application's data import paths and ensure format-specific edge cases are covered.
- Validate before seeding: Always preview mock data before bulk-importing into staging databases. Check that types, formats, and value ranges match your application's expectations.
- Use consistent ID ranges: When generating data for related tables, use matching ID ranges across tables to maintain referential integrity in your test dataset.
Popular Use Cases for Mock Data Generation
Database Seeding
Populate MySQL, PostgreSQL, or SQLite development databases with thousands of realistic records using generated INSERT statements.
API Prototyping
Generate JSON mock payloads to test REST and GraphQL endpoints before your backend produces real data.
Load & Performance Testing
Produce 10,000–100,000 row datasets to stress-test database queries, indexes, and application response times.
Frontend Development
Create realistic JSON datasets to power UI component development, table pagination, and search features.
Data Migration Testing
Verify ETL pipelines and data migration scripts with large sample datasets before touching production data.
Demos & Training
Fill demo applications with believable data for client presentations, workshops, and developer onboarding.