Fake Data Generator

Generate realistic fake data instantly -- persons, emails, phones, addresses, companies, text, numbers, dates, UUIDs, colors, passwords, credit cards, IPs, URLs, and fully custom schemas. Supports English and Korean locales. Zero external dependencies -- all generators are algorithmic and built from scratch (no faker.js).

Built for developers, QA engineers, data scientists, and anyone who needs realistic test data without touching a real database.

---

What It Does

Fake Data Generator creates synthetic but realistic-looking data on demand. Choose from 15 built-in data types or define a custom schema to mix and match fields. Generate 1 to 1,000 records per run with support for English (US) and Korean (KR) locales.

The custom schema feature is especially powerful: define your own object shape using spec strings like person.fullName, person.email, number:18-65, or date.past, and the generator fills in realistic values for each field.

Key Capabilities

• 15 Built-in Data Types: person, email, phone, address, company, text, number, date, uuid, color, password, creditCard, ip, url, custom
• Custom Schema Engine: Define any object shape and the generator fills it with realistic data
• Bilingual Support: English (US) and Korean (KR) locales for names, addresses, and phone numbers
• Bulk Generation: Generate 1 to 1,000 records per run
• Zero External Dependencies: All generators are algorithmic -- no faker.js or external data files
• Deterministic Structure: Output fields are always consistent for each data type
• Instant Results: Generates 1,000 records in under 1 second

---

What Data You Get

Person

Field	Type	Description
id	string	UUID v4 unique identifier
firstName	string	First name (locale-aware)
lastName	string	Last name (locale-aware)
fullName	string	Full name (format varies by locale)
email	string	Realistic email address
phone	string	Phone number in locale format (+1-xxx-xxx-xxxx or 010-xxxx-xxxx)
address	object	Full address (street, city, state, zip, country)
company	string	Company name
avatar	string	Avatar URL (pravatar.cc)
birthDate	string	ISO 8601 date (past 50 years)
createdAt	string	ISO 8601 date (past 2 years)

Email

Field	Type	Description
email	string	Realistic email (first name + random number @ random domain)

Phone

Field	Type	Description
phone	string	US format: +1-xxx-xxx-xxxx / KR format: 010-xxxx-xxxx

Address

Field	Type	Description
street	string	Street address
city	string	City name
state	string	State abbreviation (US) or empty (KR)
zip	string	5-digit ZIP code
country	string	"US" or "KR"

Company

Field	Type	Description
company	string	Company name (prefix + suffix combination)

Text

Field	Type	Description
text	string	Lorem ipsum words, sentences, or paragraphs

Number

Field	Type	Description
value	number	Integer or float in the specified range

Date

Field	Type	Description
date	string	ISO 8601 date (past, future, or between two dates)

UUID

Field	Type	Description
uuid	string	UUID v4 format

Color

Field	Type	Description
color	string/object	Hex string (#aabbcc), RGB object ({r, g, b}), or HSL object ({h, s, l})

Password

Field	Type	Description
password	string	Generated password with configurable length and complexity

Credit Card

Field	Type	Description
creditCard	string	Test Visa (4xxx) or Mastercard (51xx-55xx) number

IP Address

Field	Type	Description
ip	string	IPv4 (x.x.x.x) or IPv6 (xxxx:xxxx:...)

URL

Field	Type	Description
url	string	Random URL with protocol, domain, and path

---

How to Use

Basic Usage

1. Open the Fake Data Generator on Apify
2. Select a data type (default: person)
3. Set the count (default: 10)
4. Click "Start"
5. View and download results from the "Dataset" tab

Custom Schema

1. Set data type to custom
2. Enter a JSON schema in the "Custom Schema" field
3. Each key is a field name, each value is a spec string that tells the generator what to produce

---

Input Configuration

Field	Type	Required	Default	Description
dataType	string	No	person	Type of fake data to generate. One of: person (full profile with name, email, phone, address, company, avatar, dates), email, phone, address, company, text, number, date, uuid, color, password, creditCard, ip, url, custom.
count	integer	No	10	Number of records to generate. Range: 1 to 1,000. Values outside this range are clamped automatically.
locale	string	No	en	Locale for generated data. en for English/US names, addresses, and phone numbers. kr for Korean names, addresses, and phone numbers. Affects: person names, addresses, phone number formats.
textType	string	No	sentence	Text generation type (only used when dataType is text). One of: words (5 random words), sentence (6-14 words), paragraph (4-8 sentences).
numberType	string	No	int	Number type (only used when dataType is number). int for integers, float for decimals (2 decimal places).
numberMin	integer	No	0	Minimum value for number generation.
numberMax	integer	No	100	Maximum value for number generation.
dateType	string	No	past	Date generation type (only used when dataType is date). past (within last year), future (within next year), between (requires dateFrom and dateTo).
dateFrom	string	No	--	Start date for between date type. ISO 8601 format (e.g., 2024-01-01).
dateTo	string	No	--	End date for between date type. ISO 8601 format (e.g., 2025-12-31).
colorFormat	string	No	hex	Color output format (only used when dataType is color). hex (#aabbcc), rgb ({r, g, b}), hsl ({h, s, l}).
passwordLength	integer	No	16	Password length (only used when dataType is password). Range: 4 to 128.
passwordComplexity	string	No	high	Password complexity. low (lowercase only), medium (lowercase + uppercase + digits), high (+ symbols).
ipVersion	string	No	v4	IP version (only used when dataType is ip). v4 for IPv4, v6 for IPv6.
customSchema	object	No	{}	Custom schema definition (only used when dataType is custom). Each key becomes a field name, each value is a spec string. See Custom Schema Specs below.

---

Custom Schema Specs

When using dataType: "custom", define your object shape using these spec strings:

Spec	Output
person.firstName	English first name
person.lastName	English last name
person.fullName	English full name
person.fullNameKr	Korean full name
person.email	Email address
person.phone	US phone number
person.phoneKr	Korean phone number
person.profile	Full person profile (EN)
person.profileKr	Full person profile (KR)
address	US address object
address.us	US address object
address.kr	Korean address object
company	Company name
text.word	Single word
text.sentence	One sentence
text.paragraph	One paragraph
uuid	UUID v4
date	Random date (past or future)
date.past	Date in the past year
date.future	Date in the next year
color.hex	Hex color (#aabbcc)
color.rgb	RGB object
color.hsl	HSL object
password	16-char high-complexity password
creditCard	Test credit card number
ip	IPv4 address
ip.v6	IPv6 address
url	Random URL
boolean	true or false
number:MIN-MAX	Random integer in range (e.g., number:18-65)
float:MIN-MAX	Random float in range (e.g., float:0-100)

Custom Schema Example

{
  "customSchema": {
    "name": "person.fullName",
    "email": "person.email",
    "age": "number:18-65",
    "bio": "text.sentence",
    "id": "uuid",
    "joinedAt": "date.past",
    "isActive": "boolean",
    "company": "company"
  },
  "dataType": "custom",
  "count": 5
}

Output:

[
  {
    "name": "Sarah Clark",
    "email": "sarah482@gmail.com",
    "age": 34,
    "bio": "Lorem ipsum dolor sit amet consectetur adipiscing elit sed do.",
    "id": "a3f2b1c8-4d5e-4f6a-8b7c-9d0e1f2a3b4c",
    "joinedAt": "2025-08-15T14:32:00.000Z",
    "isActive": true,
    "company": "Nexus AI"
  }
]

---

Output Example

Person (English)

{
  "id": "a3f2b1c8-4d5e-4f6a-8b7c-9d0e1f2a3b4c",
  "firstName": "Sarah",
  "lastName": "Clark",
  "fullName": "Sarah Clark",
  "email": "sarah482@gmail.com",
  "phone": "+1-415-832-4571",
  "address": {
    "street": "4521 Clark Ave",
    "city": "San Francisco",
    "state": "CA",
    "zip": "94102",
    "country": "US"
  },
  "company": "Nexus AI",
  "avatar": "https://i.pravatar.cc/150?u=42185",
  "birthDate": "1989-03-22T08:15:00.000Z",
  "createdAt": "2025-11-14T16:45:00.000Z"
}

Person (Korean)

{
  "id": "b4c3d2e1-5f6a-4b8c-9d0e-1f2a3b4c5d6e",
  "firstName": "서연",
  "lastName": "김",
  "fullName": "김서연",
  "email": "서연271@naver.com",
  "phone": "010-4821-7356",
  "address": {
    "street": "강남구 234번길 15",
    "city": "서울",
    "state": "",
    "zip": "06232",
    "country": "KR"
  },
  "company": "Quantum Dynamics",
  "avatar": "https://i.pravatar.cc/150?u=78432",
  "birthDate": "1995-07-11T03:20:00.000Z",
  "createdAt": "2025-06-28T09:10:00.000Z"
}

Credit Card

{
  "creditCard": "4532015112830366"
}

Custom Schema

{
  "name": "Emily Davis",
  "email": "emily387@protonmail.com",
  "age": 29,
  "bio": "Consectetur adipiscing elit sed do eiusmod tempor incididunt.",
  "id": "c5d4e3f2-6a7b-4c8d-9e0f-1a2b3c4d5e6f",
  "joinedAt": "2025-09-03T11:22:00.000Z",
  "isActive": false,
  "company": "Summit Cloud"
}

---

Cost Estimation

This actor uses the pay-per-event pricing model. You are charged per record generated.

Action	Event Count	Estimated Cost
Generate 10 persons	10 events	~$0.01 - $0.05
Generate 100 records	100 events	~$0.05 - $0.20
Generate 1,000 records	1,000 events	~$0.20 - $0.50

Execution is extremely fast (under 1 second for 1,000 records) and uses minimal compute (128 MB RAM).

---

Integration Guide

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

# Generate 50 person profiles
run = client.actor("lazymac/fake-data-generator").call(run_input={
    "dataType": "person",
    "count": 50,
    "locale": "en"
})

dataset = client.dataset(run["defaultDatasetId"])
for item in dataset.iterate_items():
    print(f"{item['fullName']} - {item['email']}")

# Generate Korean addresses
run = client.actor("lazymac/fake-data-generator").call(run_input={
    "dataType": "address",
    "count": 20,
    "locale": "kr"
})

# Custom schema for user seed data
run = client.actor("lazymac/fake-data-generator").call(run_input={
    "dataType": "custom",
    "count": 100,
    "customSchema": {
        "userId": "uuid",
        "name": "person.fullName",
        "email": "person.email",
        "age": "number:18-65",
        "role": "company",
        "createdAt": "date.past",
        "isVerified": "boolean"
    }
})

Node.js

import { ApifyClient } from 'apify-client';

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

// Generate test credit card numbers
const run = await client.actor('lazymac/fake-data-generator').call({
    dataType: 'creditCard',
    count: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(item.creditCard));

// Generate passwords
const pwRun = await client.actor('lazymac/fake-data-generator').call({
    dataType: 'password',
    count: 20,
    passwordLength: 24,
    passwordComplexity: 'high',
});

Apify API (cURL)

# Generate 100 email addresses
curl -X POST "https://api.apify.com/v2/acts/lazymac~fake-data-generator/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataType": "email", "count": 100}'

# Get results
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

---

Use Cases

• Database Seeding: Populate development and staging databases with realistic test data
• Unit Testing: Generate deterministic-structure test fixtures for automated tests
• API Prototyping: Create mock data for API responses during frontend development
• Demo Data: Fill demo environments with realistic-looking profiles and records
• Load Testing: Generate thousands of records for performance testing
• Data Pipeline Testing: Create input datasets to test ETL pipelines and data transformations
• Privacy-Safe Datasets: Replace real PII with synthetic data for development and analytics
• Localization Testing: Test applications with Korean names, addresses, and phone numbers
• Form Validation Testing: Generate edge cases for form inputs (emails, phones, passwords)
• Spreadsheet Population: Generate CSV-ready data for dashboards, charts, and pivot table demos
• Machine Learning Training: Create labeled synthetic datasets for model training and validation
• Workshop and Tutorial Data: Provide attendees with realistic sample datasets for hands-on exercises

---

Integration with Other Tools

Zapier

1. Create a Zap with your desired trigger (e.g., "New Row in Google Sheets", "Every Week" schedule)
2. Add an action: Apify -- Run Actor
3. Select lazymac/fake-data-generator and configure the data type, count, and locale
4. Add a downstream action to send results to Google Sheets, Airtable, a database API, or email

Make (Integromat)

1. Create a new scenario with the Apify module
2. Select "Run an Actor" and choose lazymac/fake-data-generator
3. Set up an iterator to process each record individually
4. Route each record to Google Sheets, a REST API, or a database module

Google Sheets Export

from apify_client import ApifyClient
import gspread
from oauth2client.service_account import ServiceAccountCredentials

# Generate 100 person profiles
client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("lazymac/fake-data-generator").call(run_input={
    "dataType": "person", "count": 100, "locale": "en"
})

dataset = client.dataset(run["defaultDatasetId"])
records = list(dataset.iterate_items())

# Write to Google Sheets
scope = ["https://spreadsheets.google.com/feeds"]
creds = ServiceAccountCredentials.from_json_keyfile_name("creds.json", scope)
gc = gspread.authorize(creds)
sheet = gc.open("Test Data").sheet1

sheet.append_row(["Name", "Email", "Phone", "City", "Company"])
for r in records:
    sheet.append_row([r["fullName"], r["email"], r["phone"], r["address"]["city"], r["company"]])

Webhooks

Configure an Apify webhook with event ACTOR.RUN.SUCCEEDED to get notified when data generation completes. The webhook payload includes the dataset ID, which you can use to fetch and process the generated records programmatically.

Database Seeding Pipeline

# Generate data, download as JSON, and import into PostgreSQL
curl -s -X POST "https://api.apify.com/v2/acts/lazymac~fake-data-generator/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataType": "person", "count": 500, "locale": "en"}' \
  | jq -c '.[]' \
  | while read -r row; do
      name=$(echo "$row" | jq -r '.fullName')
      email=$(echo "$row" | jq -r '.email')
      psql -c "INSERT INTO users (name, email) VALUES ('$name', '$email');"
    done

---

Tips and Tricks

1. Use custom schemas for realistic seed data. Instead of generating standalone emails or names, define a custom schema that mirrors your actual database table structure. This makes it trivial to import into staging environments.

2. Combine locale settings for multi-market testing. Run the actor twice -- once with locale: "en" and once with locale: "kr" -- then merge the datasets to test internationalization handling.

3. Generate edge cases intentionally. Use the number generator with extreme ranges (number:0-0 or number:-1000-1000) and the text generator with different types to cover boundary conditions in your tests.

4. Export to CSV for non-technical stakeholders. After generating data, download it as CSV from the Apify Console. CSV files can be opened directly in Excel or Google Sheets without any code.

5. Use UUIDs as primary keys. When seeding a database, generate UUIDs for each record to avoid ID collisions. The UUID generator produces properly formatted v4 UUIDs.

6. Chain with other Apify actors. Generate fake user profiles, then use a web scraper actor to test how your application handles bulk user registration or data import.

7. Keep counts reasonable for development. 10-50 records is usually enough for local development. Save the 1,000-record runs for load testing and performance benchmarking.

8. Leverage the boolean spec in custom schemas. Add "isActive": "boolean" or "isVerified": "boolean" fields to create realistic user datasets with mixed active/inactive states.

---

Frequently Asked Questions

Q: Is the generated data truly random? A: Yes. Names, emails, phone numbers, and addresses are randomly composed from curated pools. Each run produces different results. However, the output structure is always consistent for each data type.

Q: Are the credit card numbers real? A: No. The generated numbers follow Visa (4xxx) and Mastercard (51xx-55xx) prefix patterns but are random test numbers. They will not pass Luhn validation and cannot be used for real transactions.

Q: Can I generate data in languages other than English and Korean? A: Currently only English (US) and Korean (KR) are supported. The locale affects person names, addresses, and phone number formats.

Q: What is the maximum number of records per run? A: 1,000 records per run. The count is clamped to the range 1-1,000 automatically.

Q: How fast is the generation? A: Extremely fast. All generators are algorithmic with zero external API calls. 1,000 records typically complete in under 1 second.

Q: Can I define nested objects in custom schemas? A: Partially. You can use spec strings like person.profile which returns a full nested person object with address. For arbitrary nesting, the current version does not support recursive schema definitions.

Q: Do the generated emails use real domains? A: The emails use common domain names (gmail.com, yahoo.com, outlook.com, naver.com, etc.) but the mailbox names are randomly generated. These emails do not exist and will bounce if you try to send to them.

Q: How do I export the data? A: Apify datasets can be exported to JSON, CSV, XML, and Excel formats. Use the dataset export API endpoint or download directly from the Apify Console. CSV export is useful for importing into spreadsheets or databases.

Q: Is the person avatar URL a real image? A: Yes. The avatar field links to pravatar.cc, a free placeholder avatar service. Each avatar URL includes a unique seed number, so different persons get different (but deterministic) avatars.

Q: Can I use this data in production? A: The data is designed for testing and development. While it looks realistic, it should not be used as a substitute for real data in production systems. Credit card numbers are not valid, emails do not exist, and addresses may not correspond to real locations.

Q: Can I use this actor with the Apify CLI? A: Yes. Install the Apify CLI (npm install -g apify-cli), then run: apify call lazymac/fake-data-generator -i '{"dataType": "person", "count": 10}'. Results are saved to the local dataset.

Q: What happens if I set count to 0 or a negative number? A: The count is clamped to the range 1-1,000 automatically. A count of 0 will be treated as 1. Negative numbers will also be clamped to 1.

Q: Can I generate the same data twice (deterministic output)? A: No. The current version does not support a seed parameter. Each run produces different random data. If you need reproducible results, save the generated dataset and reuse it.

Q: How do I generate data that looks like real company employees? A: Use the custom schema with fields like "employeeId": "uuid", "name": "person.fullName", "email": "person.email", "department": "company", "startDate": "date.past", "salary": "number:30000-150000". This produces records that resemble actual HR data.

Q: Are Korean addresses real locations? A: Korean addresses use real district and city names (e.g., Gangnam-gu, Seoul) but the specific street numbers are randomly generated. They follow the correct format but may not correspond to actual buildings.

Q: Can I get the output as a CSV file? A: Yes. After the run completes, access your results via the Apify API with ?format=csv appended to the dataset items endpoint. You can also download CSV, JSON, XML, or Excel directly from the Apify Console dataset view.

---

Supported Data Types Summary

Type	Locale Support	Configurable Options
person	EN, KR	locale
email	--	--
phone	US, KR	locale
address	US, KR	locale
company	--	--
text	--	textType (words/sentence/paragraph)
number	--	numberType (int/float), numberMin, numberMax
date	--	dateType (past/future/between), dateFrom, dateTo
uuid	--	--
color	--	colorFormat (hex/rgb/hsl)
password	--	passwordLength, passwordComplexity
creditCard	--	--
ip	--	ipVersion (v4/v6)
url	--	--
custom	Mixed	customSchema

---

Limitations

• Maximum 1,000 records per run
• Only English (US) and Korean (KR) locales
• Credit card numbers do not pass Luhn validation
• Custom schema does not support arbitrary nesting
• No seed parameter for reproducible results (each run is random)
• Phone numbers are random and may not correspond to valid area codes

---

Changelog

• v1.0 - Initial release with 15 data types, custom schema engine, EN/KR locales, and pay-per-event pricing