Back

DinoPass API Documentation

A simple, free REST API for generating memorable passwords. Perfect for educational applications, password resets, and bulk operations.

Overview

The DinoPass API generates memorable passwords using a combination of adjectives and nouns, making them easy to remember while maintaining reasonable security. All endpoints return plain text responses, one password per line when using bulk operations.

Base URL: https://www.dinopass.com

Rate Limits

1,000 requests per hour per IP address

Rate limits are tracked per IP address using a sliding window. When the limit is exceeded, the API returns a 429 Too Many Requests status code with helpful headers:

  • X-RateLimit-Limit - Maximum requests allowed
  • X-RateLimit-Remaining - Remaining requests in current window
  • X-RateLimit-Reset - ISO timestamp when the limit resets
  • Retry-After - Seconds until you can retry

Tip: Use the bulk n parameter to get multiple passwords in a single request, reducing your API calls significantly!

API Endpoints
GET /password/simple

Generates simple, easy-to-remember passwords. Format: adjective + noun + 2-digit number

Example: happycat42

Query Parameters:
  • n (optional) - Number of passwords to generate. Default: 1, Maximum: 1,000
  • format (optional) - Response format. Options: text (default) or json
Request Examples: 
GET /password/simple
GET /password/simple?n=100
GET /password/simple?format=json
GET /password/simple?n=5&format=json
Response (Text Format - Default): 
happycat42
bravedog78
cleverbird91
Response (JSON Format): 
{
  "passwords": [
    "happycat42",
    "bravedog78",
    "cleverbird91"
  ],
  "count": 3,
  "type": "simple"
}
GET /password/strong

Generates stronger passwords with varied capitalization, leet speak substitutions, separators, and flexible number placement for enhanced security.

Example: Br@v3D0g-42

Features:
  • Variable capitalization patterns (4 different styles)
  • Leet speak character substitutions (e.g., @ for a, 3 for e)
  • Random separators (dashes, numbers)
  • Flexible number placement (start, middle, or end)
  • Variable number of digits (1-3 digits)
Query Parameters:
  • n (optional) - Number of passwords to generate. Default: 1, Maximum: 1,000
  • format (optional) - Response format. Options: text (default) or json
Request Examples: 
GET /password/strong
GET /password/strong?n=500
GET /password/strong?format=json
Response (Text Format - Default): 
Cl3v3rB1rd-99
42@ngryL10n
W1s3W0lf7
Response (JSON Format): 
{
  "passwords": [
    "Cl3v3rB1rd-99",
    "42@ngryL10n",
    "W1s3W0lf7"
  ],
  "count": 3,
  "type": "strong"
}
GET /password/custom

Generates customizable passwords with configurable length, character sets, and complexity options.

Query Parameters:
  • length (optional) - Password length. Default: 12, Range: 7-20
  • useNumbers (optional) - Include digits 0-9. Default: true
  • useSymbols (optional) - Include special characters (!@#$%^&+). Default: false
  • useCapitals (optional) - Include uppercase letters A-Z. Default: false
  • n (optional) - Number of passwords to generate. Default: 1, Maximum: 100
  • format (optional) - Response format. Options: text (default) or json
Request Examples: 
GET /password/custom
GET /password/custom?length=16&useSymbols=true&useCapitals=true
GET /password/custom?length=20&useNumbers=false&useSymbols=true
GET /password/custom?length=16&useSymbols=true&useCapitals=false&n=5&format=json
Response (Text Format - Default): 
happycat42@xyz
bravedog78!abc
Response (JSON Format): 
{
  "passwords": [
    "happycat42@xyz",
    "bravedog78!abc"
  ],
  "count": 2,
  "type": "custom"
}
Note: The custom endpoint supports up to 100 passwords per request (n ≤ 100). For larger bulk operations, use the simple or strong endpoints which support up to 1,000 passwords per request.
GET /hasword

Checks if a word exists in the DinoPass word database (adjectives or nouns).

Query Parameters:
  • word (required) - The word to check
  • format (optional) - Response format. Options: text (default) or json
Request Examples: 
GET /hasword?word=happy
GET /hasword?word=happy&format=json
Response (Text Format - Default): 
true

Returns true if the word exists, false otherwise.

Response (JSON Format): 
{
  "word": "happy",
  "exists": true
}
Bulk Operations

All password endpoints support bulk generation using the n parameter. This is the recommended approach for generating multiple passwords, as it counts as a single API request toward your rate limit.

Example: Generate 1,300 passwords in 2 requests 
GET /password/simple?n=1000
GET /password/simple?n=300

This generates 1,300 passwords using only 2 API requests instead of 1,300!

Bulk Limits:
  • /password/simple and /password/strong: Up to 1,000 passwords per request
  • /password/custom: Up to 100 passwords per request
Response Formats

All endpoints support two response formats: text (default) and JSON. Use the format query parameter to specify your preferred format.

Text Format (Default)
  • Content-Type: text/plain
  • Encoding: UTF-8
  • Format: One password per line (when using bulk operations)
  • Example: 
    happycat42
    nbravedog78
    • 
      

    


    

      
JSON Format

      
    
        
  • Content-Type: application/json
    • 
        
  • Encoding: UTF-8
    • 
        
  • Structure: Object with passwords array, count, and type fields
    • 
        
  • Example:
          
    {
  "passwords": ["happycat42", "bravedog78"],
  "count": 2,
  "type": "simple"
}
    
        
    • 
      

      

        Usage: Add ?format=json to any endpoint URL to receive JSON responses.
      

    


    

      Status Codes:
      
    
        
  • 200 OK - Success
    • 
        
  • 429 Too Many Requests - Rate limit exceeded
    • 
        
  • 500 Internal Server Error - Server error
    • 
      

    

  


  
  

    
Error Handling

    

      When rate limited (429), the response includes helpful headers and a message:
    

    

      Rate Limit Response (429):
      
HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 2024-01-15T14:30:00.000Z
Retry-After: 1800

Rate limit exceeded. Maximum 1000 requests per hour. Try again after 2:30:00 PM

    

  


  
  

    
Code Examples

    
    

      
cURL

      

        
# Single password (text format)
curl https://www.dinopass.com/password/simple

# Single password (JSON format)
curl "https://www.dinopass.com/password/simple?format=json"

# Bulk passwords (100, JSON format)
curl "https://www.dinopass.com/password/simple?n=100&format=json"

# Custom password (JSON format)
curl "https://www.dinopass.com/password/custom?length=16&useSymbols=true&useCapitals=true&format=json"

      

    


    

      
PowerShell

      

        
# Single password
Invoke-RestMethod -Uri "https://www.dinopass.com/password/simple"

# Bulk passwords (1000)
$passwords = (Invoke-RestMethod -Uri "https://www.dinopass.com/password/simple?n=1000") -split "`n"
$passwords.Count  # Should be 1000

      

    


    

      
JavaScript (Fetch API)

      

        
// Single password (text format)
fetch('https://www.dinopass.com/password/simple')
  .then(response => response.text())
  .then(password => console.log(password));

// Single password (JSON format)
fetch('https://www.dinopass.com/password/simple?format=json')
  .then(response => response.json())
  .then(data => {
    console.log('Password:', data.passwords[0]);
    console.log('Type:', data.type);
  });

// Bulk passwords with JSON format
fetch('https://www.dinopass.com/password/simple?n=100&format=json')
  .then(response => {
    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      console.error(`Rate limited. Retry after ${retryAfter} seconds`);
      return;
    }
    return response.json();
  })
  .then(data => {
    if (data) {
      console.log(`Generated ${data.count} passwords of type ${data.type}`);
      console.log('Passwords:', data.passwords);
    }
  });

      

    


    

      
Python

      

        
import requests
import json

# Single password (text format)
response = requests.get('https://www.dinopass.com/password/simple')
print(response.text)

# Single password (JSON format)
response = requests.get('https://www.dinopass.com/password/simple?format=json')
data = response.json()
print(f"Password: {data['passwords'][0]}")
print(f"Type: {data['type']}")

# Bulk passwords (JSON format)
response = requests.get('https://www.dinopass.com/password/simple?n=1000&format=json')
data = response.json()
print(f"Generated {data['count']} passwords")
print(f"Type: {data['type']}")

# Check rate limit headers
if response.status_code == 200:
    print(f"Remaining: {response.headers.get('X-RateLimit-Remaining')}")
    print(f"Reset at: {response.headers.get('X-RateLimit-Reset')}")

      

    

  


  
  

    
Common Use Cases

    
    
      
  • Bulk Password Resets: Generate passwords for multiple users at once using the n parameter
    • 
      
  • Educational Applications: Create memorable passwords for student accounts
    • 
      
  • Automated Systems: Integrate password generation into user onboarding workflows
    • 
      
  • Password Management: Generate initial passwords that users can easily remember
    • 
    

  


  
  

    
Support & Feedback

    

      For questions, issues, or feature requests, please contact us. The API is provided free of charge for legitimate use cases.
    

  


  mini-cloud
  gear-img