Faker Forge
AI驱动的模拟数据生成器与API模拟工具
文档
AI-powered fake data generator and mock database seeder for developers.
Generate realistic synthetic datasets, seed mock databases, and publish scenario-ready mocked API endpoints — all in one sharp workflow. Trusted by developers, QA engineers, and data analysts.
Prompt. Preview. Publish.
Built for teams that need production-quality test data without sacrificing speed. Generate fake records, seed databases, mock REST APIs — no scripts needed.
Who uses FakerForge?
From solo developers to enterprise QA teams — FakerForge accelerates everyone who works with data. Generate synthetic records, populate mock databases, and ship features faster.
Seed databases instantly without writing seed scripts
Stop hand-crafting seed factories. Upload your SQL schema or migration files, configure row counts, and let FakerForge generate relationship-aware synthetic data for MySQL, PostgreSQL, SQLite, and more. Export as SQL INSERT statements, JSON, or CSV and drop straight into your local or staging environment.
Realistic mock data for thorough test coverage
Generate fake user profiles, mock transactions, dummy orders, and synthetic event logs that mirror production distributions. Test edge cases — null fields, boundary values, unicode strings — with configurable constraints. Mock REST API endpoints that return realistic responses for every test scenario.
Prototype analytics pipelines with synthetic datasets
Build and validate data pipelines, dashboards, and analytical models against realistic synthetic datasets — before you have real data. Generate statistically plausible distributions, time-series records, and multi-table relational data to stress-test your aggregations and queries.
Demo-ready environments with realistic mock data
Populate staging environments and demo databases with plausible synthetic records so stakeholders see realistic UI states — not blank screens. Maintain GDPR compliance by replacing production PII with high-fidelity fake data that looks and behaves like the real thing.
Generate and seed fake data for any database.
FakerForge supports the most widely used relational and NoSQL databases. Define your schema once and export relationship-aware synthetic records in the exact format your database expects — no manual transformation required.
MySQL
Generate INSERT statements, foreign-key-safe seed files, and CSV exports for MySQL 5.7+ and MySQL 8.
PostgreSQL
COPY-compatible exports and schema-aware JSONB fake data for PostgreSQL 13, 14, 15, and 16.
SQLite
Lightweight SQL seed files for SQLite — perfect for local dev, mobile app testing, and CI pipelines.
MariaDB
MySQL-compatible synthetic data exports that work seamlessly with MariaDB 10.x and 11.x.
MongoDB
Export realistic fake documents as BSON-ready JSON arrays for MongoDB collections and Atlas clusters.
BigQuery
Generate newline-delimited JSON for BigQuery load jobs and analytics pipeline testing at scale.
JSON / REST
Framework-agnostic JSON output for seeding any ORM, data store, or custom API endpoint.
CSV / Parquet
Flat-file exports for spreadsheet tools like microsoft excel and google sheets, data warehouse imports, and analytics workloads.
Powerful capabilities for modern data workflows.
AI-Powered Synthetic Data Generation
Our AI algorithms generate statistically realistic fake records that mirror real-world data distributions. Test edge cases, stress-test queries, and simulate production traffic with synthetic data that behaves like the real thing — names, emails, addresses, timestamps, UUIDs, and custom field types.
GDPR-Compliant Mock Data — No Real PII
FakerForge generates 100% synthetic, fictitious data. No real names, no real emails, no real phone numbers — ever. Replace production database backups in staging with compliant synthetic datasets. Stay safe under GDPR, CCPA, HIPAA, and PCI-DSS without compromising test realism.
Scenario-Based REST API Mocking
Define mock API endpoints with multiple scenarios — success states, error responses, edge cases, timeouts. Each scenario returns configurable fake JSON payloads. Decouple frontend development from backend APIs and let your team build features in parallel with realistic dummy API responses.
High-Volume Seed Data at Scale
Generate thousands of relational records while preserving foreign key integrity and referential consistency. No orphaned rows. No broken joins. Seed your entire database schema — users, orders, transactions, events — with synthetic data that holds together under real query load.
MCP Server for AI Coding Assistants
Connect FakerForge directly to GitHub Copilot, Claude, Cursor, and Windsurf via the Model Context Protocol. Ask your AI assistant to seed your database, add columns, or scaffold a mock API — all from the chat panel, without context switching. The fastest path from schema to seeded database.
Multi-Format Export — SQL, JSON, CSV
Export your generated fake data in the format your workflow demands. Download SQL INSERT scripts ready to run against MySQL or PostgreSQL. Export JSON arrays for API fixtures. Generate CSV files for spreadsheet imports, data warehouse loads, or Pandas dataframes in Python.
From schema to seeded database in three steps.
FakerForge eliminates the overhead of writing and maintaining manual seed scripts. Define your database schema, configure generation rules, and get realistic synthetic data instantly — no code required.
Upload Your Schema
Paste a SQL schema, upload migration files, or define tables manually. FakerForge parses column types, relationships, constraints, and foreign keys to understand your data model.
Configure & Generate
Set row counts, configure field-level generation rules, and add custom constraints. Our AI generates realistic fake records — names, emails, dates, IDs — that respect all your schema relationships.
Export or Seed Instantly
Download SQL INSERT scripts, JSON arrays, or CSV files. Run them directly against your database, use them as API fixtures, or pipe them into your CI/CD pipeline for automated test data provisioning.
Ship faster with synthetic data in your workflow.
Teams that replace hand-crafted seed scripts and production database copies with FakerForge synthetic data report significant improvements across their entire development and testing lifecycle.
10×
Replace hours of seed script debugging with minutes of schema upload and configuration. FakerForge generates relationship-aware synthetic datasets in seconds.
Zero
Eliminate compliance risk entirely. All data generated by FakerForge is 100% synthetic — no real customer names, emails, or payment details ever enter your non-production environments.
100%
Every generated row respects foreign key constraints and relational boundaries. No orphaned records, no broken joins — synthetic data that holds together under real query pressure.
Eliminate seed script maintenance
Schema changes no longer break your entire seed setup. Update your table definition and regenerate in seconds.
Parallel frontend & backend development
Mock REST APIs with realistic dummy responses so frontend teams never wait on backend development.
CI/CD-ready test data pipelines
Export deterministic synthetic datasets that integrate into automated testing workflows and deployment pipelines.
Instant demo environments
Populate client demo databases with realistic-looking fake data so stakeholders always see a polished, data-rich product.
Analytics pipeline prototyping
Validate dashboards and aggregation queries against realistic synthetic datasets before real data exists.
Use FakerForge inside your AI coding assistant.
FakerForge ships a Model Context Protocol (MCP) server that exposes your schemas, synthetic data generation, and API mocking capabilities as native tools for any MCP-compatible AI assistant.
Point GitHub Copilot, Claude, or Cursor at your FakerForge MCP endpoint and ask it to seed your database, add columns, or scaffold a mock API — all from the chat panel, without context switching or extra tooling.
Generate synthetic fake data via chat
Ask your AI assistant to generate realistic mock rows for any schema directly from the chat panel.
Manage database schemas conversationally
Add tables and columns, or remove them, without leaving your editor or switching context.
Create and query mock REST APIs
Scaffold mocked endpoints with dummy response payloads and inspect them via natural language prompts.
Works with any MCP-compatible client
Compatible with GitHub Copilot, Claude Desktop, Cursor, Windsurf, and any tool supporting the Model Context Protocol.
Seed your local database from the command line.
The open-source FakerForge CLI introspects your local or private PostgreSQL and MySQL databases, generates realistic synthetic data, and pushes it straight into your tables — no dump files, no seed scripts.
Only the schema shape is uploaded. Your database credentials stay in your OS keychain and never reach FakerForge.
curl -sSL https://raw.githubusercontent.com/kwasii1/fakerforge-db-agent/main/install.sh | sh
fakerforge login
fakerforge schema pull --connection local --tables users,orders --rows 100
fakerforge push --schema <schema-id> --connection local
Seed PostgreSQL and MySQL directly
Push generated rows into your database with parameterized, batched inserts — parents first, so foreign keys just work.
Credentials never leave your machine
Database passwords and API keys live in your OS keychain. FakerForge only ever sees the schema shape.
Built for CI/CD pipelines
Script it with environment variables, use --dry-run to preview, and fail fast with health checks via fakerforge status.
Install in seconds on any OS
Install script, Homebrew, go install, or prebuilt binaries for Linux, macOS, and Windows on amd64 and arm64.
Guides on synthetic data, database seeding & API mocking.
Seed Your Local Database From the Terminal With the FakerForge CLI
The FakerForge CLI introspects your local PostgreSQL or MySQL database, generates realistic synthetic data, and pushes it straight into your tables. No dump files, no seed scripts, and your database credentials never leave your machine.
CLI Database Seeding PostgreSQL
By Kwasi Sakyi Baidoo Read Article →
Faker API Generator: Create Realistic Dummy Data for Postgres, JSON, and App Testing
Looking for a faker API, faker generator, or fake data tool for PostgreSQL and apps? Learn how schema-based generation creates realistic test data fast.
Faker API Faker Generator Test Data
By Kwasi Sakyi Baidoo Read Article →
Choose your velocity.
Start free — generate synthetic data, seed mock databases, and mock APIs at no cost. Upgrade when your team needs higher volume, more databases, and advanced features.
$0.00
per month
For testing, prototyping, and small synthetic data experiments.
1 Databases
50000 AI Tokens
100 Rows / table
10 Tables / database
500 API requests
1 Mock APIs
5 Endpoints / mock
2 Scenarios / endpoint
500 Mock requests
Popular
$10.00
per month
For indie developers, QA engineers, and growing product teams.
5 Databases
1000000 AI Tokens
1000 Rows / table
20 Tables / database
10000 API requests
10 Mock APIs
50 Endpoints / mock
10 Scenarios / endpoint
10000 Mock requests
$20.00
per month
For data teams and startups shipping mock data at scale.
20 Databases
5000000 AI Tokens
100000 Rows / table
50 Tables / database
50000 API requests
50 Mock APIs
100 Endpoints / mock
50 Scenarios / endpoint
100000 Mock requests
The best free fake data generator for developers and QA teams.
FakerForge is a free AI-powered fake data generator and mock database seeder designed for software developers, QA engineers, and data analysts. Instead of writing brittle seed scripts or copying production databases into staging, FakerForge lets you describe your schema and instantly generates thousands of realistic synthetic records that respect all your relational constraints.
Unlike simple online faker tools, FakerForge understands your full schema — tables, columns, data types, foreign keys, unique constraints — and generates relationship-aware fake data that holds together under real query conditions. Export to SQL, JSON, or CSV and drop it directly into MySQL, PostgreSQL, SQLite, MariaDB, or MongoDB.
Beyond database seeding, FakerForge includes a full REST API mocking platform. Define mock endpoints with configurable dummy response payloads across multiple scenarios — 200 OK, 404 Not Found, 500 Server Error — so frontend developers can build against realistic APIs without waiting for backend implementation.
With native MCP server integration, your AI coding assistants can seed databases, manage schemas, and scaffold mock APIs directly from the chat interface. FakerForge is the fastest path from zero data to a fully seeded development environment — no scripts, no production data copies, no compliance risk.