Random User Generator Actor

An Apify Actor that generates random user data using the MultipleWords API. Filter by gender and nationalities, control which fields to include or exclude, and get structured user profiles (name, email, location, picture, login, and more) for testing, demos, or seed data.

Demo

• Open on Apify Console – View the Actor and run it from the Apify dashboard
• Run the Actor – Start a run with custom input
• Apify Store – Browse and run Actors (publish this Actor to appear here)

Replace YOUR_USERNAME with your Apify username after deployment.

What This Tool Does

This Actor connects to the MultipleWords random users API to generate fake but realistic user profiles. It accepts filters (gender, nationalities), pagination, optional seeds for reproducibility, and lets you include or exclude specific fields. Results are pushed to the default dataset and returned as structured JSON.

Key Features

• Generate random user profiles with name, email, location, phone, picture, and more
• Filter by gender (male/female) and nationalities (e.g. AU, US, IN)
• Include or exclude fields (gender, name, location, email, login, registered, dob, phone, cell, id, picture, nat)
• Pagination and optional seeds for reproducible results
• Custom password pattern for generated users
• Structured output in dataset and HTTP response
• Standby mode with HTTP API for real-time requests
• Batch mode for one-off runs with input from storage

Purpose & Use Cases

Development & Testing

• Seed databases with realistic user data
• Test forms, sign-up flows, and user profiles
• Generate test accounts with configurable fields
• Reproducible data via seeds

Demos & Prototypes

• Populate demo apps and dashboards
• Show sample user lists and profile pages
• A/B test UI with varied user data

Integration & Automation

• Feed user-like data into pipelines (Make, Zapier, custom APIs)
• Batch generate users for staging environments
• Use via Apify API or HTTP in standby mode

Data & Analytics

• Create sample datasets for analytics or ML
• Filter by nationality or gender for localized demos
• Control output schema with include/exclude fields

Input Parameters

All parameters are optional. Omitted values use API defaults.

gender (Optional)

Type: String
Description: Filter results by gender.
Options: male, female
Default: male

passwords (Optional)

Type: String
Description: Custom password pattern for generated users (e.g. S@ify123).
Example: S@ify123

seeds (Optional)

Type: String
Description: Seed for reproducible random results (e.g. foobar). Same seed yields same users.
Example: foobar

nationalities (Optional)

Type: String
Description: Comma-separated nationality codes (e.g. AU, IND, US).
Example: AU, IND, US

pagination (Optional)

Type: Integer
Description: Page number for paginated results (1-based).
Default: 1
Minimum: 1

inc (Optional)

Type: String
Description: Comma-separated list of fields to include only. Leave empty for all fields.
Options: gender, name, location, email, login, registered, dob, phone, cell, id, picture, nat
Example: name, email, picture

exc (Optional)

Type: String
Description: Comma-separated list of fields to exclude.
Options: Same as inc.
Example: login, id

Output Structure

Dataset (default)

Each random user is pushed as one dataset item. Example shape:

{
  "gender": "female",
  "name": {
    "title": "Ms",
    "first": "Emma",
    "last": "Wilson"
  },
  "location": {
    "street": { "number": 1234, "name": "Main St" },
    "city": "Sydney",
    "state": "New South Wales",
    "country": "Australia",
    "postcode": "2000",
    "coordinates": { "latitude": "-33.8688", "longitude": "151.2093" },
    "timezone": { "offset": "+10:00", "description": "Eastern Australia" }
  },
  "email": "emma.wilson@example.com",
  "login": {
    "uuid": "...",
    "username": "smallostrich123",
    "password": "hashed...",
    "salt": "...",
    "md5": "...",
    "sha1": "...",
    "sha256": "..."
  },
  "dob": { "date": "1990-05-15T...", "age": 33 },
  "registered": { "date": "2020-01-10T...", "age": 3 },
  "phone": "02 1234 5678",
  "cell": "0412 345 678",
  "id": { "name": "...", "value": "..." },
  "picture": {
    "large": "https://...",
    "medium": "https://...",
    "thumbnail": "https://..."
  },
  "nat": "AU"
}

HTTP response (standby mode)

POST to / returns:

{
  "results": [ /* same user objects as above */ ],
  "info": {
    "seed": "...",
    "results": 1,
    "page": 1,
    "version": "..."
  }
}

Output fields (summary)

• gender – male/female
• name – title, first, last
• location – street, city, state, country, postcode, coordinates, timezone
• email – email address
• login – username, password hashes (when not excluded)
• registered – registration date
• dob – date of birth and age
• phone, cell – phone numbers
• id – ID name/value
• picture – large, medium, thumbnail URLs
• nat – nationality code

How to Use

Running locally

1. Install dependencies:

   $npm install
   

2. Run the Actor:

   $apify run
   

3. Provide input when prompted, or put input in storage/key_value_stores/default/INPUT.json:

   {
     "gender": "female",
     "nationalities": "AU, US",
     "pagination": 1,
     "inc": "name, email, picture, location"
   }
   

Deploy to Apify

1. Log in to Apify:

   $apify login
   

2. Deploy the Actor:

   $apify push
   

3. Run from Console:

   • Go to Actors → My Actors
   • Open Random User Generator
   • Set input (gender, nationalities, inc/exc, etc.) and click Start

Using the API

After deployment, run via Apify API:

curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~random-user-generator-apify/run-sync" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "gender": "female",
    "nationalities": "AU, US",
    "pagination": 1
  }'

Using the Apify client (Node.js)

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('YOUR_USERNAME/random-user-generator-apify').call({
  gender: 'female',
  nationalities: 'AU, US',
  pagination: 1,
  inc: 'name, email, picture',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log('Users:', items);

Using HTTP API (standby mode)

When the Actor runs in standby mode, send POST requests to the root path:

curl -X POST http://localhost:8080/ \
  -H "Content-Type: application/json" \
  -d '{
    "gender": "male",
    "nationalities": "US, GB",
    "pagination": 1,
    "inc": "name, email, picture"
  }'

Replace localhost:8080 with the Actor’s URL when run on Apify (e.g. container URL in standby).

Integration examples

With Make (Integromat)

• Trigger the Actor on a schedule or webhook
• Map dataset items to your app’s user model
• Send generated users to Airtable, Google Sheets, or your API

With Zapier

• Run the Actor from a Zap and use results in later steps
• Create “fake” users in CRMs or sign-up flows for testing

With custom apps

• Call the Actor via Apify API or standby HTTP
• Use results to seed dev/staging databases or demo UIs

With Node.js

import { ApifyClient } from 'apify-client';

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

async function getRandomUsers(options = {}) {
  const run = await client.actor('YOUR_USERNAME/random-user-generator-apify').call(options);
  const { items } = await client.dataset(run.defaultDatasetId).listItems();
  return items;
}

const users = await getRandomUsers({
  gender: 'female',
  nationalities: 'AU, IN',
  inc: 'name, email, picture',
});
console.log(users);

Technical details

• Runtime: Node.js 18+
• Dependencies: Apify SDK v3.5.2+
• API endpoint: https://shorts.multiplewords.com/mwvideos/api/random_users
• Request method: GET (query parameters built from input)
• Standby mode: Enabled (HTTP server on port 8080)
• Input: JSON validated via .actor/input_schema.json
• Output: Default dataset (one item per user) and optional HTTP JSON response

Error handling

• Validates and normalizes input (e.g. nationalities, inc/exc)
• Handles API errors and non-OK responses with clear logs
• Uses apify/log for logging (sensitive data censored)
• Graceful shutdown on aborting event
• Readiness probe support for standby mode (x-apify-container-server-readiness-probe)

Resources

• Apify SDK for JavaScript
• Apify Platform
• Apify Academy – Node.js
• Apify Community
• Video: Getting data with Apify API

Support

For issues, feature ideas, or questions, use the Apify documentation and community forums.

---

Built with Apify SDK