# Fake Test Data Generator (`automation-lab/fake-test-data-generator`) Actor

Generate bulk fake/test data using @faker-js/faker. Create realistic persons, addresses, companies, finance records, and internet profiles. 50+ locales, reproducible seeds, 50 field types.

- **URL**: https://apify.com/automation-lab/fake-test-data-generator.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 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`](https://fakerjs.dev/) — 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](https://apify.com/automation-lab/fake-test-data-generator) 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](https://apify.com/automation-lab/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:
```json
{
  "count": 500,
  "locale": "en",
  "fields": ["firstName", "lastName", "email", "phone", "companyName", "jobTitle", "city", "country"]
}
````

Generate a German user database:

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

Generate reproducible product catalog:

```json
{
  "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:**

```json
{
  "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:**

```json
{
  "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:**

```json
{
  "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](https://apify.com/automation-lab/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](https://apify.com/automation-lab/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**

```javascript
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**

```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**

```bash
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)](https://docs.apify.com/platform/integrations/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

```bash
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:

```json
{
    "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](https://docs.apify.com/platform/integrations/mcp).

### 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](https://apify.com/automation-lab/uuid-generator) — Generate bulk UUIDs (v1, v4, v7)
- ✅ [Email MX Verifier](https://apify.com/automation-lab/email-mx-verifier) — Verify email deliverability via MX lookup
- 📱 [Phone Number Validator](https://apify.com/automation-lab/phone-number-validator) — Validate and format international phone numbers
- 🔒 [Password Strength Checker](https://apify.com/automation-lab/password-strength-checker) — Analyze password strength and entropy
- 📊 [JSON Schema Generator](https://apify.com/automation-lab/json-schema-generator) — Generate JSON Schema from sample data
- 🧹 [Dataset Deduplicator](https://apify.com/automation-lab/dataset-dedup) — Remove duplicates from Apify datasets
- 🕵️ [IBAN Validator](https://apify.com/automation-lab/iban-validator) — Validate and decode IBAN bank account numbers

# Actor input Schema

## `count` (type: `integer`):

How many fake records to generate. Minimum 1, maximum 100,000.

## `locale` (type: `string`):

Locale for generated data. Affects names, addresses, phone formats, etc. Use standard locale codes like 'en', 'de', 'fr', 'es', 'ja', 'zh\_CN', etc.

## `fields` (type: `array`):

Select which fields to include in each record. Available: firstName, lastName, fullName, prefix, suffix, gender, email, phone, username, password, avatar, birthDate, age, streetAddress, city, state, zipCode, country, countryCode, latitude, longitude, companyName, companySuffix, companyEmail, catchPhrase, bs, department, jobTitle, accountNumber, iban, bic, creditCardNumber, creditCardType, currency, currencyCode, price, url, domainName, ipv4, ipv6, mac, userAgent, color, uuid, boolean, number, word, sentence, paragraph, productName, productCategory, productDescription, productAdjective, sku

## `seed` (type: `integer`):

Optional seed for reproducible results. Same seed + same inputs always produce the same data. Leave empty for random output.

## Actor input object example

```json
{
  "count": 10,
  "locale": "en",
  "fields": [
    "firstName",
    "lastName",
    "email",
    "phone",
    "streetAddress",
    "city",
    "country",
    "companyName",
    "jobTitle"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "count": 10,
    "locale": "en",
    "fields": [
        "firstName",
        "lastName",
        "email",
        "phone",
        "streetAddress",
        "city",
        "country",
        "companyName",
        "jobTitle"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fake-test-data-generator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "count": 10,
    "locale": "en",
    "fields": [
        "firstName",
        "lastName",
        "email",
        "phone",
        "streetAddress",
        "city",
        "country",
        "companyName",
        "jobTitle",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fake-test-data-generator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "count": 10,
  "locale": "en",
  "fields": [
    "firstName",
    "lastName",
    "email",
    "phone",
    "streetAddress",
    "city",
    "country",
    "companyName",
    "jobTitle"
  ]
}' |
apify call automation-lab/fake-test-data-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/fake-test-data-generator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fake Test Data Generator",
        "description": "Generate bulk fake/test data using @faker-js/faker. Create realistic persons, addresses, companies, finance records, and internet profiles. 50+ locales, reproducible seeds, 50 field types.",
        "version": "0.1",
        "x-build-id": "GSfKufqMdqVebxGiL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fake-test-data-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fake-test-data-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~fake-test-data-generator/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fake-test-data-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~fake-test-data-generator/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fake-test-data-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "count",
                    "fields"
                ],
                "properties": {
                    "count": {
                        "title": "🔢 Number of records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "How many fake records to generate. Minimum 1, maximum 100,000.",
                        "default": 10
                    },
                    "locale": {
                        "title": "🌍 Locale",
                        "enum": [
                            "af_ZA",
                            "ar",
                            "az",
                            "cs_CZ",
                            "da",
                            "de",
                            "de_AT",
                            "de_CH",
                            "el",
                            "en",
                            "en_AU",
                            "en_CA",
                            "en_GB",
                            "en_IE",
                            "en_IN",
                            "en_NG",
                            "en_US",
                            "en_ZA",
                            "es",
                            "es_MX",
                            "fa",
                            "fi",
                            "fr",
                            "fr_BE",
                            "fr_CA",
                            "fr_CH",
                            "he",
                            "hr",
                            "hu",
                            "hy",
                            "id_ID",
                            "it",
                            "ja",
                            "ka_GE",
                            "ko",
                            "lv",
                            "mk",
                            "nb_NO",
                            "nl",
                            "nl_BE",
                            "pl",
                            "pt_BR",
                            "pt_PT",
                            "ro",
                            "ru",
                            "sk",
                            "sr_RS_cyrillic",
                            "sv",
                            "th",
                            "tr",
                            "uk",
                            "ur",
                            "vi",
                            "zh_CN",
                            "zh_TW",
                            "zu_ZA"
                        ],
                        "type": "string",
                        "description": "Locale for generated data. Affects names, addresses, phone formats, etc. Use standard locale codes like 'en', 'de', 'fr', 'es', 'ja', 'zh_CN', etc.",
                        "default": "en"
                    },
                    "fields": {
                        "title": "📊 Fields to generate",
                        "type": "array",
                        "description": "Select which fields to include in each record. Available: firstName, lastName, fullName, prefix, suffix, gender, email, phone, username, password, avatar, birthDate, age, streetAddress, city, state, zipCode, country, countryCode, latitude, longitude, companyName, companySuffix, companyEmail, catchPhrase, bs, department, jobTitle, accountNumber, iban, bic, creditCardNumber, creditCardType, currency, currencyCode, price, url, domainName, ipv4, ipv6, mac, userAgent, color, uuid, boolean, number, word, sentence, paragraph, productName, productCategory, productDescription, productAdjective, sku",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "firstName",
                            "lastName",
                            "email",
                            "phone",
                            "streetAddress",
                            "city",
                            "country",
                            "companyName",
                            "jobTitle"
                        ]
                    },
                    "seed": {
                        "title": "🌱 Random seed",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional seed for reproducible results. Same seed + same inputs always produce the same data. Leave empty for random output."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```