Fake Test Data Generator

Generate bulk fake, realistic test data for development, QA, demos, and load testing using the industry-standard @faker-js/faker library. Create thousands of records with names, emails, addresses, companies, finance data, internet fields, and more — with locale support for 50+ languages.

What does Fake Test Data Generator do?

Fake Test Data Generator produces realistic, randomized synthetic records based on your configuration. You choose which fields to include (person info, contact details, addresses, company data, finance fields, internet data, or product info), set a locale for region-specific formatting, and optionally use a seed for reproducible output.

The actor uses @faker-js/faker — the most widely used fake data library — and runs as a pure compute utility with no proxy and no external API calls. Generate up to 100,000 records per run and export as JSON, CSV, or Excel.

Try it directly from the Apify Store with no coding required.

Who is Fake Test Data Generator for?

Developers and QA engineers building and testing applications:

• 🛠️ Populate a dev database with thousands of realistic users, orders, or products
• 🧪 Generate consistent test fixtures with a seed value for repeatable CI test suites
• 🔄 Reset staging environments with fresh, varied data on each run

Data scientists and analysts:

• 📊 Create synthetic datasets for training ML models without exposing real PII
• 📈 Benchmark data pipelines and ETL processes with controlled, large datasets
• 🧮 Test data validation rules and schema constraints with edge-case inputs

Sales and marketing teams doing demos:

• 🎯 Populate CRM demos with realistic leads and companies instead of "John Doe"
• 📋 Generate sample reports and dashboards with plausible-looking data
• 🌍 Localize demos for German, French, Japanese, or Spanish audiences with matching locale data

Security and compliance teams:

• 🔒 Replace production data in non-prod environments with GDPR-safe synthetic data
• 🛡️ Test PII detection and masking systems with known fake data
• 📋 Validate data retention and anonymization pipelines

Why use Fake Test Data Generator?

• ✅ No proxy, no API key, no login — pure compute utility, starts in seconds
• 🌍 50+ locales — German names, Japanese addresses, French phone numbers
• 🔁 Reproducible output — set a seed and get identical data every run
• 📦 50 field types across 7 categories: person, contact, address, company, finance, internet, product
• 💾 Export as JSON, CSV, or Excel — Apify handles format conversion automatically
• ⚡ Fast and cheap — generate 10,000 records in seconds for fractions of a cent
• 🔗 API-ready — integrate with n8n, Make, Zapier, or call directly from your CI pipeline

What data can you extract?

Category	Fields
👤 Person	firstName, lastName, fullName, prefix (Mr/Ms), suffix (Jr/Sr), gender
📞 Contact	email, phone, username, password, avatar (URL)
📅 Dates	birthDate (ISO), age
📍 Address	streetAddress, city, state, zipCode, country, countryCode, latitude, longitude
🏢 Company	companyName, companySuffix, companyEmail, catchPhrase, bs (buzzPhrase), department, jobTitle
💳 Finance	accountNumber, iban, bic, creditCardNumber, creditCardType, currency, currencyCode, price
🌐 Internet	url, domainName, ipv4, ipv6, mac, userAgent, color
📦 Product	productName, productCategory, productDescription, productAdjective, sku
🔧 Misc	uuid, boolean, number, word, sentence, paragraph

How much does it cost to generate fake test data?

Fake Test Data Generator uses Pay-Per-Event (PPE) pricing — you pay only for what you generate.

Plan	Start fee	Per record	1,000 records	10,000 records
Free ($5 credit)	$0.005	$0.000575	$0.58	$5.75
Starter (BRONZE)	$0.005	$0.0005	$0.51	$5.05
Scale (SILVER)	$0.005	$0.00039	$0.40	$3.95
Business (GOLD)	$0.005	$0.0003	$0.31	$3.05
Enterprise (PLATINUM)	$0.005	$0.0002	$0.21	$2.05
Enterprise (DIAMOND)	$0.005	$0.00014	$0.15	$1.45

On the free plan ($5 credit): You can generate approximately 8,600 records before spending your $5 credit.

There are no proxy costs — this actor runs entirely on Apify compute with no external requests.

How to generate fake test data

1. Go to Fake Test Data Generator on the Apify Store
2. Click Try for free
3. Set Number of records (e.g., 100)
4. Choose a Locale (e.g., en for English, de for German)
5. Set Fields to generate — paste a JSON array like ["firstName", "lastName", "email", "phone"]
6. Optionally set a seed for reproducible output
7. Click Start and wait a few seconds
8. Download results as JSON, CSV, or Excel

Example inputs:

Generate a CRM lead list:

{
  "count": 500,
  "locale": "en",
  "fields": ["firstName", "lastName", "email", "phone", "companyName", "jobTitle", "city", "country"]
}

Generate a German user database:

{
  "count": 1000,
  "locale": "de",
  "fields": ["fullName", "email", "phone", "streetAddress", "city", "zipCode", "iban", "birthDate"]
}

Generate reproducible product catalog:

{
  "count": 200,
  "locale": "en",
  "seed": 42,
  "fields": ["productName", "productCategory", "productDescription", "sku", "price", "uuid"]
}

Input parameters

Parameter	Type	Required	Default	Description
count	integer	✅	10	Number of records to generate (1–100,000)
locale	string	—	en	Locale for localized data (50+ options)
fields	array	✅	["firstName", ...]	Array of field names to include in each record
seed	integer	—	—	Random seed for reproducible output. Same seed = same data

Supported locales include: en, en_US, en_GB, de, de_AT, de_CH, fr, fr_CA, fr_CH, es, es_MX, it, ja, ko, zh_CN, zh_TW, pt_BR, pt_PT, ru, ar, nl, pl, sv, da, fi, nb_NO, tr, id_ID, vi, th, he, uk, and more.

Output examples

Each record is a flat JSON object containing only the fields you requested:

Person + contact + address:

{
  "firstName": "Sophia",
  "lastName": "Müller",
  "email": "sophia.mueller@example.de",
  "phone": "+49 30 12345678",
  "streetAddress": "Berliner Str. 42",
  "city": "Hamburg",
  "zipCode": "20095",
  "country": "Germany"
}

Finance record:

{
  "fullName": "Max Mustermann",
  "iban": "DE89 3704 0044 0532 0130 00",
  "bic": "COBADEFFXXX",
  "creditCardNumber": "4532-1234-5678-9012",
  "creditCardType": "visa",
  "currency": "Euro",
  "currencyCode": "EUR",
  "price": "$1,249.99"
}

Product catalog:

{
  "productName": "Ergonomic Granite Chair",
  "productCategory": "Outdoors",
  "productDescription": "Carbonite web goalkeeper gloves are ergonomically designed to give precision.",
  "sku": "ERGCHR0042",
  "price": "$349.00",
  "uuid": "550e8400-e29b-41d4-a716-446655440000"
}

Tips for best results

• 🎯 Start small — run 10–50 records first to verify the output looks right before generating thousands
• 🌱 Use seeds for CI/CD — set seed: 12345 and your pipeline always gets identical test fixtures
• 📏 Keep fields minimal — only include fields you actually need to minimize file size
• 🌍 Match locale to use case — de for German app testing, ja for Japanese, zh_CN for Chinese Simplified
• 🔄 Schedule for fresh data — use Apify's scheduler to regenerate test data on a weekly cadence
• 📦 Combine with other actors — use this actor to seed email lists, then validate them with Email MX Verifier

Integrations

Fake Test Data Generator → Google Sheets (via Apify integration): Generate 1,000 leads and push them to a Google Sheet automatically for sales team demos or CRM imports.

Fake Test Data Generator → n8n/Make workflow: Trigger a weekly run to refresh staging database with fresh synthetic user records. Use the webhook to notify your team when new data is ready.

Fake Test Data Generator → CI/CD pipeline: Call the actor via API on each PR build with seed: $PR_NUMBER to generate deterministic test fixtures that are consistent across pipeline runs.

Fake Test Data Generator → Email validation: Generate 500 fake email addresses, then pipe them through Email MX Verifier to test your validation logic against realistic-looking but fake addresses.

Fake Test Data Generator → PostgreSQL/MySQL: Export as CSV and use Apify's dataset download URL in your database seeding scripts (COPY command for Postgres, LOAD DATA INFILE for MySQL).

Using the Apify API

Automate fake data generation from your codebase:

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/fake-test-data-generator').call({
  count: 1000,
  locale: 'en',
  fields: ['firstName', 'lastName', 'email', 'phone', 'companyName'],
  seed: 42,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Generated ${items.length} fake records`);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/fake-test-data-generator').call(run_input={
    'count': 1000,
    'locale': 'de',
    'fields': ['fullName', 'email', 'iban', 'phone', 'streetAddress', 'city'],
    'seed': 99,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['fullName'], item['email'])

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fake-test-data-generator/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "count": 100,
    "locale": "en",
    "fields": ["firstName", "lastName", "email", "phone", "companyName", "jobTitle"],
    "seed": 1
  }'

Use with AI agents via MCP

Fake Test Data Generator is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com"

Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts

Once connected, try asking your AI assistant:

• "Use automation-lab/fake-test-data-generator to generate 200 fake user records with firstName, lastName, email, and phone in German locale"
• "Generate a reproducible product catalog with 500 items using seed 42, including productName, sku, price, and productCategory"
• "Create 1000 fake company records with companyName, jobTitle, companyEmail, and catchPhrase for a CRM demo"

Learn more in the Apify MCP documentation.

Is it legal to use Fake Test Data Generator?

Yes — entirely. This actor generates purely synthetic data using mathematical algorithms. It does not scrape any website, does not access any external API, and does not process or store real personal data.

All output is fabricated using @faker-js/faker. No real person's information is involved. The generated data is suitable for use in development, testing, and demos without any privacy concerns.

For production use cases requiring data anonymization of real datasets, consider a purpose-built anonymization tool.

FAQ

How fast does it generate data? Very fast. A run of 10,000 records typically completes in under 10 seconds (256 MB compute, no network requests). Runs of 100,000 records complete in under 60 seconds.

How much does it cost to generate 10,000 records? About $5.05 on the Starter plan ($0.005 start + $0.0005 × 10,000). On the Scale plan it's $3.95. See the pricing table above for all tiers.

Can I get the same data every time? Yes — set the seed parameter to any integer. Runs with the same seed, locale, fields, and count always produce identical output. This is ideal for CI/CD pipelines and reproducible test fixtures.

What locales are available? 50+ locales including English (US, UK, AU, CA, IE, IN), German, French, Spanish, Japanese, Korean, Chinese (Simplified/Traditional), Portuguese (Brazil/Portugal), Russian, Arabic, Dutch, Polish, Swedish, Italian, and many more. See the locale parameter for the full list.

Why do some address fields look slightly inconsistent with the locale? Some locales in @faker-js/faker have partial coverage — for example, a locale may have city names but fall back to English for state names. This is a known limitation of the faker library. For full consistency, use widely-supported locales like en, de, fr, es, pt_BR, ja.

Can I generate nested objects? No — all output fields are flat primitives (strings, numbers, booleans). This makes the data directly importable into spreadsheets and SQL databases without transformation.

Why are some field values not exactly what I expected? Different @faker-js/faker versions may change field formats. If you need stable formats, use the seed parameter and pin to a specific actor version.

Other utility actors

• 🔑 UUID Generator — Generate bulk UUIDs (v1, v4, v7)
• ✅ Email MX Verifier — Verify email deliverability via MX lookup
• 📱 Phone Number Validator — Validate and format international phone numbers
• 🔒 Password Strength Checker — Analyze password strength and entropy
• 📊 JSON Schema Generator — Generate JSON Schema from sample data
• 🧹 Dataset Deduplicator — Remove duplicates from Apify datasets
• 🕵️ IBAN Validator — Validate and decode IBAN bank account numbers