MCP Servers/Password Generator Utilities

Password Generator Utilities

utilities

active

Generate secure, customizable passwords with various complexity options through MCP protocol

utilitiesmcputilitiesai-tools

API Access Requires Subscription

While you can view all details here, using this MCP server's API requires a Enterprise subscription. API calls with FREE plan keys will return an access error.

View Pricing Plans

Available Tools

analyze_password_strength

tool

Analyze the strength and security characteristics of a password

generate_memorable_password

tool

Generate memorable passwords using word patterns for better usability

generate_multiple_passwords

tool

Generate multiple secure passwords with the same settings

generate_password

tool

Generate a single secure password with customizable options

Documentation

Password Generator Documentation

Password Generator MCP Server

Overview

The Password Generator MCP server provides comprehensive password generation and analysis functionality through the Model Context Protocol (MCP). This server provides comprehensive functionality.

🔧 Exposed Tools

This MCP server exposes 4 tools for AI agents:

1. generate_password

Purpose: Generate a single secure password with customizable options

  • Input: type (random|memorable|pin|custom), length (4-128), character set options
  • Output: Generated password with strength analysis
  • Example: Random 16-character password with symbols

2. generate_multiple_passwords

Purpose: Generate multiple secure passwords with the same settings

  • Input: count (1-100), password configuration options
  • Output: Array of generated passwords with batch statistics
  • Example: Generate 10 secure passwords for team distribution

3. generate_memorable_password

Purpose: Generate memorable passwords using word patterns for better usability

  • Input: wordCount (2-6), separator, number/capitalization options
  • Output: Human-friendly password like "Quick-River-Dance-2024"
  • Example: "Mountain-Eagle-River-77" (easier to remember)

4. analyze_password_strength

Purpose: Analyze the strength and security characteristics of a password

  • Input: password, detailed feedback options
  • Output: Comprehensive strength analysis, score, and improvement suggestions
  • Example: 85/100 strength score with specific recommendations

🔗 Server Details

  • Category: Utilities / Security
  • Transport: Server-Sent Events (SSE)
  • Endpoint: /api/mcp/utilities/password-generator/sse
  • Authentication: Required (PRO/ENTERPRISE plans)
  • Wrapped API: /api/utilities/password-generator/v1

📋 Prerequisites

  • Subscription: PRO or ENTERPRISE plan
  • API Key: Valid API key with Password Generator access
  • MCP Client: Any MCP-compatible client or AI agent

🚀 Quick Start

Connection Setup

Endpoint: https://apistack.online/api/mcp/utilities/password-generator/sse
Method: POST
Headers:
  Content-Type: application/json
  Authorization: Bearer YOUR_API_KEY

Basic MCP Requests

List Available Tools

{
  "jsonrpc": "2.0",
  "id": "list-tools",
  "method": "tools/list"
}

Generate Random Password

{
  "jsonrpc": "2.0",
  "id": "gen-1",
  "method": "tools/call",
  "params": {
    "name": "generate_password",
    "arguments": {
      "type": "random",
      "length": 16,
      "includeLowercase": true,
      "includeUppercase": true,
      "includeNumbers": true,
      "includeSymbols": true,
      "excludeSimilar": true
    }
  }
}

Generate Memorable Password

{
  "jsonrpc": "2.0",
  "id": "mem-1",
  "method": "tools/call",
  "params": {
    "name": "generate_memorable_password",
    "arguments": {
      "wordCount": 3,
      "separator": "-",
      "includeNumbers": true,
      "capitalizeWords": true
    }
  }
}

Analyze Password Strength

{
  "jsonrpc": "2.0",
  "id": "analyze-1",
  "method": "tools/call",
  "params": {
    "name": "analyze_password_strength",
    "arguments": {
      "password": "MySecureP@ssw0rd!",
      "includeDetailedFeedback": true
    }
  }
}

💻 Implementation Examples

Python Example

import requests
import json

class PasswordGeneratorMCPClient:
    def __init__(self, base_url, api_key):
        self.base_url = base_url
        self.headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {api_key}"
        }
        self.endpoint = f"{base_url}/api/mcp/utilities/password-generator/sse"
    
    def generate_password(self, password_type="random", length=16, **options):
        request = {
            "jsonrpc": "2.0",
            "id": "generate",
            "method": "tools/call",
            "params": {
                "name": "generate_password",
                "arguments": {
                    "type": password_type,
                    "length": length,
                    **options
                }
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]["content"][0]["text"]
    
    def generate_multiple_passwords(self, count=5, **options):
        request = {
            "jsonrpc": "2.0",
            "id": "generate-multiple",
            "method": "tools/call",
            "params": {
                "name": "generate_multiple_passwords",
                "arguments": {
                    "count": count,
                    **options
                }
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]["content"][0]["text"]
    
    def generate_memorable_password(self, word_count=3, separator="-", **options):
        request = {
            "jsonrpc": "2.0",
            "id": "memorable",
            "method": "tools/call",
            "params": {
                "name": "generate_memorable_password",
                "arguments": {
                    "wordCount": word_count,
                    "separator": separator,
                    **options
                }
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]["content"][0]["text"]
    
    def analyze_password_strength(self, password, detailed=True):
        request = {
            "jsonrpc": "2.0",
            "id": "analyze",
            "method": "tools/call",
            "params": {
                "name": "analyze_password_strength",
                "arguments": {
                    "password": password,
                    "includeDetailedFeedback": detailed
                }
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]["content"][0]["text"]

# Usage Examples
client = PasswordGeneratorMCPClient("https://apistack.online", "YOUR_API_KEY")

# Generate a secure random password
secure_password = client.generate_password(
    type="random",
    length=20,
    includeLowercase=True,
    includeUppercase=True,
    includeNumbers=True,
    includeSymbols=True,
    excludeSimilar=True
)
print(f"Secure Password: {secure_password}")

# Generate memorable password
memorable = client.generate_memorable_password(
    word_count=4,
    separator="-",
    includeNumbers=True,
    capitalizeWords=True
)
print(f"Memorable Password: {memorable}")

# Analyze password strength
analysis = client.analyze_password_strength("MyOldPassword123", detailed=True)
print(f"Password Analysis: {analysis}")

# Generate multiple passwords for team
team_passwords = client.generate_multiple_passwords(
    count=10,
    type="random",
    length=16,
    includeSymbols=True
)
print(f"Team Passwords: {team_passwords}")

JavaScript/Node.js Example

const axios = require('axios');

class PasswordGeneratorMCPClient {
    constructor(baseUrl, apiKey) {
        this.baseUrl = baseUrl;
        this.endpoint = `${baseUrl}/api/mcp/utilities/password-generator/sse`;
        this.headers = {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${apiKey}`
        };
    }

    async generatePassword(options = {}) {
        const request = {
            jsonrpc: "2.0",
            id: "generate",
            method: "tools/call",
            params: {
                name: "generate_password",
                arguments: {
                    type: "random",
                    length: 16,
                    includeLowercase: true,
                    includeUppercase: true,
                    includeNumbers: true,
                    includeSymbols: true,
                    ...options
                }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result.content[0].text;
    }

    async generateMultiplePasswords(count = 5, options = {}) {
        const request = {
            jsonrpc: "2.0",
            id: "generate-multiple",
            method: "tools/call",
            params: {
                name: "generate_multiple_passwords",
                arguments: {
                    count,
                    type: "random",
                    length: 16,
                    ...options
                }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result.content[0].text;
    }

    async generateMemorablePassword(options = {}) {
        const request = {
            jsonrpc: "2.0",
            id: "memorable",
            method: "tools/call",
            params: {
                name: "generate_memorable_password",
                arguments: {
                    wordCount: 3,
                    separator: "-",
                    includeNumbers: true,
                    capitalizeWords: true,
                    ...options
                }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result.content[0].text;
    }

    async analyzePasswordStrength(password, includeDetailedFeedback = true) {
        const request = {
            jsonrpc: "2.0",
            id: "analyze",
            method: "tools/call",
            params: {
                name: "analyze_password_strength",
                arguments: {
                    password,
                    includeDetailedFeedback
                }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result.content[0].text;
    }
}

// Usage Examples
(async () => {
    const client = new PasswordGeneratorMCPClient("https://apistack.online", "YOUR_API_KEY");
    
    try {
        // Generate secure password
        const securePassword = await client.generatePassword({
            type: "random",
            length: 20,
            excludeSimilar: true,
            excludeAmbiguous: true
        });
        console.log("Secure Password:", securePassword);

        // Generate memorable password
        const memorablePassword = await client.generateMemorablePassword({
            wordCount: 4,
            separator: ".",
            includeNumbers: true
        });
        console.log("Memorable Password:", memorablePassword);

        // Analyze password strength
        const analysis = await client.analyzePasswordStrength("TestPassword123!");
        console.log("Password Analysis:", analysis);

        // Generate multiple passwords
        const multiplePasswords = await client.generateMultiplePasswords(5, {
            length: 12,
            type: "random"
        });
        console.log("Multiple Passwords:", multiplePasswords);

    } catch (error) {
        console.error("Error:", error.response?.data || error.message);
    }
})();

.NET Core Example

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class PasswordGeneratorMCPClient
{
    private readonly HttpClient _httpClient;
    private readonly string _endpoint;

    public PasswordGeneratorMCPClient(string baseUrl, string apiKey)
    {
        _httpClient = new HttpClient();
        _endpoint = $"{baseUrl}/api/mcp/utilities/password-generator/sse";
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
    }

    public async Task<string> GeneratePasswordAsync(object options = null)
    {
        var defaultOptions = new
        {
            type = "random",
            length = 16,
            includeLowercase = true,
            includeUppercase = true,
            includeNumbers = true,
            includeSymbols = true
        };

        var request = new
        {
            jsonrpc = "2.0",
            id = "generate",
            method = "tools/call",
            @params = new
            {
                name = "generate_password",
                arguments = options ?? defaultOptions
            }
        };

        return await SendRequestAsync(request);
    }

    public async Task<string> GenerateMultiplePasswordsAsync(int count, object options = null)
    {
        var request = new
        {
            jsonrpc = "2.0",
            id = "generate-multiple",
            method = "tools/call",
            @params = new
            {
                name = "generate_multiple_passwords",
                arguments = new
                {
                    count,
                    type = "random",
                    length = 16,
                    includeLowercase = true,
                    includeUppercase = true,
                    includeNumbers = true,
                    includeSymbols = true
                }
            }
        };

        return await SendRequestAsync(request);
    }

    public async Task<string> GenerateMemorablePasswordAsync(int wordCount = 3, string separator = "-")
    {
        var request = new
        {
            jsonrpc = "2.0",
            id = "memorable",
            method = "tools/call",
            @params = new
            {
                name = "generate_memorable_password",
                arguments = new
                {
                    wordCount,
                    separator,
                    includeNumbers = true,
                    capitalizeWords = true
                }
            }
        };

        return await SendRequestAsync(request);
    }

    public async Task<string> AnalyzePasswordStrengthAsync(string password, bool includeDetailedFeedback = true)
    {
        var request = new
        {
            jsonrpc = "2.0",
            id = "analyze",
            method = "tools/call",
            @params = new
            {
                name = "analyze_password_strength",
                arguments = new
                {
                    password,
                    includeDetailedFeedback
                }
            }
        };

        return await SendRequestAsync(request);
    }

    private async Task<string> SendRequestAsync(object request)
    {
        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await _httpClient.PostAsync(_endpoint, content);
        var responseJson = await response.Content.ReadAsStringAsync();
        
        using var doc = JsonDocument.Parse(responseJson);
        return doc.RootElement.GetProperty("result")
                  .GetProperty("content")[0]
                  .GetProperty("text").GetString();
    }
}

// Usage Examples
class Program
{
    static async Task Main(string[] args)
    {
        var client = new PasswordGeneratorMCPClient("https://apistack.online", "YOUR_API_KEY");
        
        try
        {
            // Generate secure password
            var securePasswordOptions = new
            {
                type = "random",
                length = 20,
                includeLowercase = true,
                includeUppercase = true,
                includeNumbers = true,
                includeSymbols = true,
                excludeSimilar = true
            };
            
            var securePassword = await client.GeneratePasswordAsync(securePasswordOptions);
            Console.WriteLine($"Secure Password: {securePassword}");

            // Generate memorable password
            var memorablePassword = await client.GenerateMemorablePasswordAsync(4, ".");
            Console.WriteLine($"Memorable Password: {memorablePassword}");

            // Analyze password strength
            var analysis = await client.AnalyzePasswordStrengthAsync("MyTestPassword123!", true);
            Console.WriteLine($"Password Analysis: {analysis}");

            // Generate multiple passwords
            var multiplePasswords = await client.GenerateMultiplePasswordsAsync(5);
            Console.WriteLine($"Multiple Passwords: {multiplePasswords}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

🔒 Security & Authentication

  • Authentication Required: All requests must include a valid Bearer token
  • Plan Restrictions: Only PRO and ENTERPRISE users can access this MCP server
  • Rate Limiting: 60 requests/minute, 1000 requests/hour, 10,000 requests/day
  • Input Validation: All inputs are validated for type, length, and format
  • Secure Generation: Uses cryptographically secure random number generation
  • No Logging: Generated passwords are never logged or stored

📊 Response Format

All tool responses follow the MCP protocol format:

Success Response

{
  "jsonrpc": "2.0",
  "id": "request-id",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "✅ **Password Generated Successfully**\n\n**Generated Password:**\n```\nK9mN#pQ2vX8$wE4z\n```\n\n**Password Details:**\n- Length: 16 characters\n- Strength: Very Strong (95/100)\n- Character Types: Uppercase, Lowercase, Numbers, Symbols\n- Estimated Time to Crack: 2.4 million years"
      }
    ]
  }
}

Error Response

{
  "jsonrpc": "2.0",
  "id": "request-id",
  "error": {
    "code": -32603,
    "message": "Invalid password length. Must be between 4 and 128 characters.",
    "data": "Length provided: 200"
  }
}

🧪 Testing

Test the Password Generator MCP server:

# Test all tools
curl -X POST http://apistack.online/api/mcp/utilities/password-generator/sse \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "tools/call",
    "params": {
      "name": "generate_password",
      "arguments": {
        "type": "random",
        "length": 16,
        "includeSymbols": true
      }
    }
  }'

🏗️ Architecture

AI Agent/Client
       ↓
MCP Protocol (JSON-RPC 2.0)
       ↓
Password Generator MCP Server (/api/mcp/utilities/password-generator/sse)
       ↓
Authentication & Validation
       ↓
Password Generator API (/api/utilities/password-generator/v1)
       ↓
Secure Random Generation + Analysis
       ↓
Response via MCP Protocol

📝 Tool Schemas

generate_password Schema

{
  "name": "generate_password",
  "description": "Generate a single secure password with customizable options",
  "inputSchema": {
    "type": "object",
    "properties": {
      "type": {
        "type": "string",
        "enum": ["random", "memorable", "pin", "custom"],
        "default": "random",
        "description": "Type of password to generate"
      },
      "length": {
        "type": "number",
        "minimum": 4,
        "maximum": 128,
        "default": 16,
        "description": "Length of the password"
      },
      "includeLowercase": {
        "type": "boolean",
        "default": true,
        "description": "Include lowercase letters (a-z)"
      },
      "includeUppercase": {
        "type": "boolean",
        "default": true,
        "description": "Include uppercase letters (A-Z)"
      },
      "includeNumbers": {
        "type": "boolean",
        "default": true,
        "description": "Include numbers (0-9)"
      },
      "includeSymbols": {
        "type": "boolean",
        "default": true,
        "description": "Include symbols (!@#$%^&*)"
      },
      "excludeSimilar": {
        "type": "boolean",
        "default": false,
        "description": "Exclude similar-looking characters (0, O, l, 1, I)"
      },
      "excludeAmbiguous": {
        "type": "boolean",
        "default": false,
        "description": "Exclude ambiguous characters ({}, [], (), etc.)"
      },
      "customCharset": {
        "type": "string",
        "description": "Custom character set for password generation (for 'custom' type)",
        "minLength": 4
      }
    },
    "required": []
  }
}

generate_multiple_passwords Schema

{
  "name": "generate_multiple_passwords",
  "description": "Generate multiple secure passwords with the same settings",
  "inputSchema": {
    "type": "object",
    "properties": {
      "count": {
        "type": "number",
        "minimum": 1,
        "maximum": 100,
        "default": 5,
        "description": "Number of passwords to generate"
      },
      "type": {
        "type": "string",
        "enum": ["random", "memorable", "pin", "custom"],
        "default": "random",
        "description": "Type of password to generate"
      },
      "length": {
        "type": "number",
        "minimum": 4,
        "maximum": 128,
        "default": 16,
        "description": "Length of the password"
      }
    },
    "required": ["count"]
  }
}

generate_memorable_password Schema

{
  "name": "generate_memorable_password",
  "description": "Generate memorable passwords using word patterns for better usability",
  "inputSchema": {
    "type": "object",
    "properties": {
      "wordCount": {
        "type": "number",
        "minimum": 2,
        "maximum": 6,
        "default": 3,
        "description": "Number of words to use in the password"
      },
      "separator": {
        "type": "string",
        "default": "-",
        "description": "Character to separate words",
        "maxLength": 1
      },
      "includeNumbers": {
        "type": "boolean",
        "default": true,
        "description": "Add numbers to the end for extra security"
      },
      "capitalizeWords": {
        "type": "boolean",
        "default": true,
        "description": "Randomly capitalize first letters of words"
      }
    },
    "required": []
  }
}

analyze_password_strength Schema

{
  "name": "analyze_password_strength",
  "description": "Analyze the strength and security characteristics of a password",
  "inputSchema": {
    "type": "object",
    "properties": {
      "password": {
        "type": "string",
        "description": "The password to analyze",
        "minLength": 1
      },
      "includeDetailedFeedback": {
        "type": "boolean",
        "default": true,
        "description": "Include detailed feedback and suggestions"
      }
    },
    "required": ["password"]
  }
}

🎯 Use Cases

Enterprise Password Management

  • Generate secure passwords for new employee accounts
  • Create temporary passwords for system access
  • Analyze existing password policies

Development & Testing

  • Generate test passwords for applications
  • Create sample data with realistic password patterns
  • Validate password generation algorithms

Personal Security

  • Create strong passwords for personal accounts
  • Generate memorable passwords for important services
  • Analyze and improve existing passwords

🤝 Support

For issues, feature requests, or integration help:

  • Check the API documentation
  • Review the examples above
  • Test with the provided curl commands
  • Contact support for PRO/ENTERPRISE users

Note: This MCP server requires a PRO or ENTERPRISE subscription and valid API authentication. The server provides comprehensive functionality workflows.

Quick Info

Endpoint
/api/mcp/utilities/password-generator/sse
Transport
Server-Sent Events (SSE)
Tools Available
4
Plan Required
PRO, ENTERPRISE

MCP Configuration

Add this configuration to your MCP client:

Note: Replace "YOUR_API_KEY" with a valid Enterprise API key. FREE plan keys will receive access errors.

{
  "mcpServers": {
    "password-generator-utilities": {
      "command": "curl",
      "args": [
        "-X",
        "POST",
        "https://apistack.online/api/mcp/utilities/password-generator/sse",
        "-H",
        "Content-Type: application/json",
        "-H",
        "Authorization: Bearer YOUR_API_KEY",
        "--data-raw",
        "@-"
      ],
      "transport": "sse"
    }
  }
}

Try It Out

Use the MCP configuration above in your AI client, or test the underlying APIs in our playground.

API playground requires a Enterprise subscription for access.

Open in Playground