# Password Generator (`maximedupre/password-generator`) Actor

Generate secure passwords in bulk with custom length, character sets, policy rules, and optional bcrypt, scrypt, or SHA-256 hashes. Export one row per password for QA, onboarding, provisioning, API workflows, and spreadsheets.

- **URL**: https://apify.com/maximedupre/password-generator.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.45 / 1,000 generated passwords

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

### 🔐 Password generator for secure bulk secrets

Password Generator creates secure passwords in bulk from the policy you choose. Set the length, character sets, minimum digits and symbols, compliance profile, and optional hash output, then get one saved dataset row per generated password.

Use it as a password generator API for QA data, test accounts, onboarding batches, internal tools, secret provisioning, spreadsheet exports, and repeatable automation. The Actor runs fully inside Apify. It does not need cookies, user accounts, browser extensions, source websites, or third-party API keys.

For a quick first run, keep the defaults. They generate 10 passwords, 16 characters each, with lowercase letters, uppercase letters, digits, symbols, and at least one digit and one symbol per password.

### ✅ What this password generator does

- Generates one dataset row per password.
- Supports 1 to 10,000 generated passwords in one run.
- Supports password length from 4 to 128 characters.
- Lets you include or remove lowercase letters, uppercase letters, digits, and symbols.
- Lets you require every selected character type.
- Lets you set minimum digit and symbol counts.
- Can start each password with a letter.
- Can avoid ambiguous characters that are easy to confuse.
- Can avoid duplicate characters and simple sequential characters.
- Includes policy profiles: Custom settings, Strict, Enterprise, Banking, and Government.
- Can add bcrypt, scrypt, or SHA-256 hashes beside each password.

Profile settings are applied before generation. For example, stricter profiles can raise the applied length, enable required character sets, and turn on policy restrictions so the generated password matches the chosen profile.

### 📊 Data you get

Each saved item is one generated password. Rows include:

| Field | Description |
| --- | --- |
| `id` | Row identifier such as `pwd_000001`. |
| `password` | Generated plaintext password. |
| `hash` | Generated bcrypt, scrypt, or SHA-256 hash, or `null` when plain output is selected. |
| `hashType` | Hash mode used for the row: `none`, `bcrypt`, `scrypt`, or `sha256`. |
| `policy` | Applied policy after profile handling, including length, selected character sets, minimums, and restrictions. |
| `characterCounts` | Lowercase, uppercase, digit, and symbol counts found in the password. |
| `generatedAt` | ISO timestamp for when the password was generated. |

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or use it from the Apify API, schedules, webhooks, and integrations.

### ⚙️ How to run it

1. Choose the number of passwords.
2. Set the password length.
3. Choose Custom settings or a policy profile.
4. Pick the character sets and policy rules.
5. Choose whether to add a hash beside each password.
6. Run the Actor and open the dataset.

The Actor validates impossible policies before saving misleading rows. For example, if you require digits but disable the digit character set, the run stops cleanly and explains what to change.

### 📥 Input options

The main inputs are:

- `quantity`: number of passwords to generate, from 1 to 10,000.
- `length`: characters per password, from 4 to 128.
- `complianceProfile`: `none`, `strict`, `enterprise`, `banking`, or `government`.
- Character set toggles for lowercase, uppercase, digits, and symbols.
- Policy rules for minimum digits, minimum symbols, begin-with-letter, ambiguous-character avoidance, duplicate avoidance, and sequential avoidance.
- `hashType`: `none`, `bcrypt`, `scrypt`, or `sha256`.

Argon2 is not exposed because this Actor only lists hash modes that are implemented and validated.

### 📤 Output example

```json
{
  "id": "pwd_000001",
  "password": "m9#Qv2!zR8pLx4@K",
  "hash": null,
  "hashType": "none",
  "policy": {
    "length": 16,
    "profile": "none",
    "characterSets": ["lowercase", "uppercase", "digits", "symbols"],
    "requireEachSelectedType": true,
    "minDigits": 1,
    "minSymbols": 1,
    "beginWithLetter": false,
    "avoidAmbiguous": false,
    "noDuplicateCharacters": false,
    "noSequentialCharacters": false
  },
  "characterCounts": {
    "lowercase": 5,
    "uppercase": 4,
    "digits": 4,
    "symbols": 3
  },
  "generatedAt": "2026-06-22T17:30:00.000Z"
}
````

### 💳 Pricing

This Actor charges per generated password. You pay only for passwords that are successfully generated and saved.

The planned price is $0.00045 per generated password, or $0.45 per 1,000 generated passwords, for every Apify tier in the local pricing file.

### ⚠️ Limits and notes

This is a generator utility, not a password manager or secret vault. It does not store credentials outside the normal Apify run storage you control, rotate passwords later, recover old passwords from a seed, or deploy passwords to other services.

Use the exported dataset carefully. Generated plaintext passwords are secrets. Download, share, and store them only in systems you trust.

### ❓ FAQ

#### 🔌 Can I use this as a password generator API?

Yes. Run it through the Apify API with your chosen input JSON, then read the default dataset items from the run.

#### 🔑 Can it generate hashes instead of only plaintext passwords?

Yes. Set `hashType` to `bcrypt`, `scrypt`, or `sha256`. The output keeps the plaintext password and adds the hash beside it so you can provision accounts or test systems that need both values.

#### 🧭 Does it use an external password source?

No. Passwords are generated inside the Actor runtime from your selected policy. The Actor does not scrape websites or call an external password API.

#### ⚙️ What happens with impossible settings?

The Actor stops cleanly before saving rows. For example, it will not emit passwords when your minimum digit and symbol counts cannot fit within the selected length.

### 📝 Changelog

- 1.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~password-generator/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Email MX Verifier ↗](https://apify.com/maximedupre/email-mx-verifier) - Check email syntax, MX records, disposable domains, and delivery risk.
- [SMTP Email Verifier ↗](https://apify.com/maximedupre/smtp-email-verifier) - Probe email mailboxes with SMTP checks without sending messages.
- [Profanity Checker ↗](https://apify.com/maximedupre/profanity-checker) - Clean text snippets and export match evidence for moderation workflows.
- [Sitemap Validator ↗](https://apify.com/maximedupre/sitemap-validator) - Validate sitemap URLs, redirects, response times, and sitemap metadata.
- [Robots.txt Generator ↗](https://apify.com/maximedupre/robots-txt-generator) - Generate deployable robots.txt files from presets, rules, and sitemap URLs.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `quantity` (type: `integer`):

How many password rows to generate.

## `length` (type: `integer`):

Number of characters in each generated password.

## `complianceProfile` (type: `string`):

Choose a preset policy, or keep Custom to use the detailed rules below.

## `includeLowercase` (type: `boolean`):

Allow lowercase letters such as a-z.

## `includeUppercase` (type: `boolean`):

Allow uppercase letters such as A-Z.

## `includeDigits` (type: `boolean`):

Allow digits such as 0-9.

## `includeSymbols` (type: `boolean`):

Allow symbols such as !, @, #, and %.

## `requireEachSelectedType` (type: `boolean`):

Make each password include at least one character from every enabled character type.

## `minDigits` (type: `integer`):

Minimum number of digits each password must contain.

## `minSymbols` (type: `integer`):

Minimum number of symbols each password must contain.

## `beginWithLetter` (type: `boolean`):

Make each password start with a lowercase or uppercase letter.

## `avoidAmbiguous` (type: `boolean`):

Exclude characters that are easy to confuse when copied or read manually.

## `noDuplicateCharacters` (type: `boolean`):

Make each character appear at most once in a password.

## `noSequentialCharacters` (type: `boolean`):

Avoid simple ascending or descending character sequences.

## `hashType` (type: `string`):

Add a hash beside each generated password when you need stored-secret provisioning.

## Actor input object example

```json
{
  "quantity": 10,
  "length": 16,
  "complianceProfile": "none",
  "includeLowercase": true,
  "includeUppercase": true,
  "includeDigits": true,
  "includeSymbols": true,
  "requireEachSelectedType": true,
  "minDigits": 1,
  "minSymbols": 1,
  "beginWithLetter": false,
  "avoidAmbiguous": false,
  "noDuplicateCharacters": false,
  "noSequentialCharacters": false,
  "hashType": "none"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with one row per generated password.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/password-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/password-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 '{}' |
apify call maximedupre/password-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Password Generator",
        "description": "Generate secure passwords in bulk with custom length, character sets, policy rules, and optional bcrypt, scrypt, or SHA-256 hashes. Export one row per password for QA, onboarding, provisioning, API workflows, and spreadsheets.",
        "version": "1.0",
        "x-build-id": "EEWQ5wxnOFBG2pgny"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~password-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-password-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/maximedupre~password-generator/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-password-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/maximedupre~password-generator/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-password-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",
                "properties": {
                    "quantity": {
                        "title": "Number of passwords",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many password rows to generate.",
                        "default": 10
                    },
                    "length": {
                        "title": "Password length",
                        "minimum": 4,
                        "maximum": 128,
                        "type": "integer",
                        "description": "Number of characters in each generated password.",
                        "default": 16
                    },
                    "complianceProfile": {
                        "title": "Policy profile",
                        "enum": [
                            "none",
                            "strict",
                            "enterprise",
                            "banking",
                            "government"
                        ],
                        "type": "string",
                        "description": "Choose a preset policy, or keep Custom to use the detailed rules below.",
                        "default": "none"
                    },
                    "includeLowercase": {
                        "title": "Include lowercase letters",
                        "type": "boolean",
                        "description": "Allow lowercase letters such as a-z.",
                        "default": true
                    },
                    "includeUppercase": {
                        "title": "Include uppercase letters",
                        "type": "boolean",
                        "description": "Allow uppercase letters such as A-Z.",
                        "default": true
                    },
                    "includeDigits": {
                        "title": "Include digits",
                        "type": "boolean",
                        "description": "Allow digits such as 0-9.",
                        "default": true
                    },
                    "includeSymbols": {
                        "title": "Include symbols",
                        "type": "boolean",
                        "description": "Allow symbols such as !, @, #, and %.",
                        "default": true
                    },
                    "requireEachSelectedType": {
                        "title": "Require every selected character type",
                        "type": "boolean",
                        "description": "Make each password include at least one character from every enabled character type.",
                        "default": true
                    },
                    "minDigits": {
                        "title": "Minimum digits",
                        "minimum": 0,
                        "maximum": 128,
                        "type": "integer",
                        "description": "Minimum number of digits each password must contain.",
                        "default": 1
                    },
                    "minSymbols": {
                        "title": "Minimum symbols",
                        "minimum": 0,
                        "maximum": 128,
                        "type": "integer",
                        "description": "Minimum number of symbols each password must contain.",
                        "default": 1
                    },
                    "beginWithLetter": {
                        "title": "Begin with a letter",
                        "type": "boolean",
                        "description": "Make each password start with a lowercase or uppercase letter.",
                        "default": false
                    },
                    "avoidAmbiguous": {
                        "title": "Avoid ambiguous characters",
                        "type": "boolean",
                        "description": "Exclude characters that are easy to confuse when copied or read manually.",
                        "default": false
                    },
                    "noDuplicateCharacters": {
                        "title": "Avoid duplicate characters",
                        "type": "boolean",
                        "description": "Make each character appear at most once in a password.",
                        "default": false
                    },
                    "noSequentialCharacters": {
                        "title": "Avoid sequential characters",
                        "type": "boolean",
                        "description": "Avoid simple ascending or descending character sequences.",
                        "default": false
                    },
                    "hashType": {
                        "title": "Hash output",
                        "enum": [
                            "none",
                            "bcrypt",
                            "scrypt",
                            "sha256"
                        ],
                        "type": "string",
                        "description": "Add a hash beside each generated password when you need stored-secret provisioning.",
                        "default": "none"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```