# Synthetic User Profile & Mock Data Generator (`crawlyth-forge/synthetic-user-profile-and-mock-data-generator`) Actor

Generate randomized, realistic-looking user profiles for test and demo data: name, email, phone, address with coordinates, date of birth, profile picture, and optional username and hashed password, filterable by gender and nationality.

- **URL**: https://apify.com/crawlyth-forge/synthetic-user-profile-and-mock-data-generator.md
- **Developed by:** [crawlyth forge](https://apify.com/crawlyth-forge) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Synthetic User Profile & Mock Data Generator

Need realistic-looking fake people for a demo, a UI mockup, or a test database seed? This actor generates fully fictional user profiles — name, contact details, address, date of birth and a profile picture — with no real individuals involved.

### What this actor does

- **Generates any volume of profiles** in one run, each one an independently generated fictional person.
- **Gender filter** — male, female, or a mix of both.
- **Nationality filter** — restrict generated profiles to one or more supported countries.
- **Optional extras** — toggle profile pictures on/off, and optionally include a generated username plus hashed (never plaintext) password.
- Fields that aren't requested or that a given profile doesn't carry (e.g. coordinates when the location has none) are omitted rather than returned empty.

### Output per profile

- `fullName`, `firstName`, `lastName`, `title` — name components, with a salutation title (e.g. Mr, Ms)
- `gender`
- `email`, `phone`, `cell`
- `nationality` — ISO country code
- `dateOfBirth`, `age`
- `streetAddress`, `city`, `state`, `country`, `postcode`
- `latitude`, `longitude` — generated location coordinates
- `timezone`
- `pictureUrl`, `pictureThumbnail` — when `includePicture` is on
- `username`, `uuid`, `passwordMd5`, `passwordSha256` — when `includeLogin` is on (only hashed password forms are ever returned, never plaintext)
- `registeredDate`
- `recordType` — always `user_profile`
- `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `count` | integer | `100` | How many profiles to generate (1–5000) |
| `gender` | string | `any` | `any`, `male`, or `female` |
| `nationalities` | array | `[]` | ISO country codes to restrict generation to (`AU`, `BR`, `CA`, `CH`, `DE`, `DK`, `ES`, `FI`, `FR`, `GB`, `IE`, `IN`, `IR`, `MX`, `NL`, `NO`, `NZ`, `RS`, `TR`, `UA`, `US`); empty = any |
| `includePicture` | boolean | `true` | Include `pictureUrl`/`pictureThumbnail` |
| `includeLogin` | boolean | `false` | Include generated `username`, `uuid`, and hashed password fields |

#### Example: 500 generic test profiles

```json
{
  "count": 500
}
```

#### Example: female profiles from a set of European nationalities

```json
{
  "count": 200,
  "gender": "female",
  "nationalities": ["DE", "FR", "ES", "NL"]
}
```

#### Example: login-ready test accounts without pictures

```json
{
  "count": 50,
  "includePicture": false,
  "includeLogin": true
}
```

### Use cases

- **QA test data** — seed a staging database with realistic-looking users without using real personal data.
- **UI/UX mockups** — populate design prototypes with varied names, photos and addresses.
- **Load testing** — generate large batches of synthetic accounts for registration/login flow testing.
- **Demo environments** — fill a sales demo with plausible-looking sample users.
- **Anonymization reference data** — use generated profiles as stand-ins when documenting data models.

### FAQ

**Are these real people?**
No. Every profile is synthetically generated and does not correspond to any real individual, email address, or phone number.

**Is the password field a real, usable password?**
No — `passwordMd5`/`passwordSha256` are generated hash values for test purposes only; there is no corresponding plaintext password and these fields aren't tied to any real account.

**Can I get only one nationality?**
Yes — set `nationalities` to a single ISO code, e.g. `["US"]`, to generate only US-styled profiles.

**Why are `latitude`/`longitude` sometimes missing?**
They're omitted when the generated location data didn't include coordinates for that profile.

**Can I generate a mix of genders in one run?**
Yes — leave `gender` set to `any` (the default) to get a mix of male and female profiles.

**Is this data usable for production accounts?**
No — this is test/demo data only and should not be used to create real user accounts or sent to real third-party services.

**Does the actor require any login or API key?**
No — generation requires no authentication of any kind.

# Actor input Schema

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

How many random users to generate.

## `gender` (type: `string`):

Filter users by gender.

## `nationalities` (type: `array`):

Filter users by nationality (ISO country codes). Leave empty for all.

## `includePicture` (type: `boolean`):

Include the user's profile picture URL in the output.

## `includeLogin` (type: `boolean`):

Include generated username and password hash in the output.

## Actor input object example

```json
{
  "count": 100,
  "gender": "any",
  "nationalities": [],
  "includePicture": true,
  "includeLogin": false
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all generated user profile records.

# 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": 100,
    "gender": "any",
    "nationalities": [],
    "includePicture": true,
    "includeLogin": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlyth-forge/synthetic-user-profile-and-mock-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": 100,
    "gender": "any",
    "nationalities": [],
    "includePicture": True,
    "includeLogin": False,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlyth-forge/synthetic-user-profile-and-mock-data-generator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": 100,
  "gender": "any",
  "nationalities": [],
  "includePicture": true,
  "includeLogin": false
}' |
apify call crawlyth-forge/synthetic-user-profile-and-mock-data-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlyth-forge/synthetic-user-profile-and-mock-data-generator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Sx3mgFv5czyoQlvjE/builds/XTVU7NR0SVcfDsDym/openapi.json
