API Key Generation Code Examples

<?php
// Generate 32-byte (256-bit) API key
function generateApiKey(int $length = 32): string {
    $bytes = random_bytes($length);
    return bin2hex($bytes);
}

// Example: 64-character hexadecimal API key
$apiKey = generateApiKey(32);
echo $apiKey;
// Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

// Base64 URL-safe encoding (shorter, 43 chars for 256 bits)
function generateApiKeyBase64(int $length = 32): string {
    $bytes = random_bytes($length);
    return rtrim(strtr(base64_encode($bytes), '+/', '-_'), '=');
}

$apiKeyBase64 = generateApiKeyBase64(32);
echo $apiKeyBase64;
// Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"

// Calculate entropy: 32 bytes = 256 bits
// Collision probability: 1 in 2^256 (astronomically low)

// Node.js implementation
const crypto = require('crypto');

function generateApiKey(length = 32) {
    return crypto.randomBytes(length).toString('hex');
}

// Generate 256-bit (32 byte) API key
const apiKey = generateApiKey(32);
console.log(apiKey);
// Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

// Base64 URL-safe encoding
function generateApiKeyBase64(length = 32) {
    return crypto.randomBytes(length)
        .toString('base64')
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
}

const apiKeyBase64 = generateApiKeyBase64(32);
console.log(apiKeyBase64);
// Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"

// Browser implementation (Web Crypto API)
function generateApiKeyBrowser(length = 32) {
    const array = new Uint8Array(length);
    crypto.getRandomValues(array);
    return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
}

import secrets
import base64

def generate_api_key(length=32):
    """Generate hexadecimal API key."""
    return secrets.token_hex(length)

# Generate 256-bit (32 byte) API key
api_key = generate_api_key(32)
print(api_key)
# Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

def generate_api_key_base64(length=32):
    """Generate base64 URL-safe API key."""
    return secrets.token_urlsafe(length)

api_key_base64 = generate_api_key_base64(32)
print(api_key_base64)
# Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"

# Generate with prefix for versioning
def generate_versioned_api_key(prefix="sk", length=32):
    """Generate API key with prefix (e.g., sk_live_, sk_test_)."""
    token = secrets.token_urlsafe(length)
    return f"{prefix}_{token}"

versioned_key = generate_versioned_api_key("sk_live", 32)
print(versioned_key)
# Output: "sk_live_p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"

import java.security.SecureRandom;
import java.util.Base64;

public class ApiKeyGenerator {
    private static final SecureRandom random = new SecureRandom();

    public static String generateApiKey(int length) {
        byte[] bytes = new byte[length];
        random.nextBytes(bytes);

        // Convert to hexadecimal
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    public static String generateApiKeyBase64(int length) {
        byte[] bytes = new byte[length];
        random.nextBytes(bytes);

        // Base64 URL-safe encoding
        return Base64.getUrlEncoder()
                     .withoutPadding()
                     .encodeToString(bytes);
    }

    public static void main(String[] args) {
        // Generate 256-bit (32 byte) API key
        String apiKey = generateApiKey(32);
        System.out.println("Hex: " + apiKey);
        // Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

        String apiKeyBase64 = generateApiKeyBase64(32);
        System.out.println("Base64: " + apiKeyBase64);
        // Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"
    }
}

using System;
using System.Security.Cryptography;

public class ApiKeyGenerator
{
    public static string GenerateApiKey(int length = 32)
    {
        using var rng = RandomNumberGenerator.Create();
        byte[] bytes = new byte[length];
        rng.GetBytes(bytes);

        // Convert to hexadecimal
        return BitConverter.ToString(bytes).Replace("-", "").ToLower();
    }

    public static string GenerateApiKeyBase64(int length = 32)
    {
        using var rng = RandomNumberGenerator.Create();
        byte[] bytes = new byte[length];
        rng.GetBytes(bytes);

        // Base64 URL-safe encoding
        return Convert.ToBase64String(bytes)
                      .Replace('+', '-')
                      .Replace('/', '_')
                      .TrimEnd('=');
    }

    public static void Main()
    {
        // Generate 256-bit (32 byte) API key
        string apiKey = GenerateApiKey(32);
        Console.WriteLine($"Hex: {apiKey}");
        // Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

        string apiKeyBase64 = GenerateApiKeyBase64(32);
        Console.WriteLine($"Base64: {apiKeyBase64}");
        // Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"
    }
}

#include <iostream>
#include <random>
#include <string>
#include <vector>
#include <sstream>
#include <iomanip>

class ApiKeyGenerator {
private:
    std::random_device rd;

public:
    std::string generateApiKey(size_t length = 32) {
        std::vector<unsigned char> bytes(length);

        // Generate random bytes
        for (size_t i = 0; i < length; ++i) {
            bytes[i] = static_cast<unsigned char>(rd() % 256);
        }

        // Convert to hexadecimal
        std::stringstream ss;
        ss << std::hex << std::setfill('0');
        for (unsigned char byte : bytes) {
            ss << std::setw(2) << static_cast<int>(byte);
        }

        return ss.str();
    }
};

int main() {
    ApiKeyGenerator generator;

    // Generate 256-bit (32 byte) API key
    std::string apiKey = generator.generateApiKey(32);
    std::cout << "API Key: " << apiKey << std::endl;
    // Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

    return 0;
}

require 'securerandom'

class ApiKeyGenerator
  def self.generate(length: 32)
    # Hexadecimal encoding (64 characters for 32 bytes)
    SecureRandom.hex(length)
  end

  def self.generate_base64(length: 32)
    # Base64 URL-safe encoding
    SecureRandom.urlsafe_base64(length)
  end

  def self.generate_with_prefix(prefix: "sk_live", length: 32)
    # Generate with version prefix
    token = SecureRandom.urlsafe_base64(length)
    "#{prefix}_#{token}"
  end
end

# Generate 256-bit (32 byte) API key
api_key = ApiKeyGenerator.generate(length: 32)
puts api_key
# Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

# Base64 URL-safe encoding
api_key_base64 = ApiKeyGenerator.generate_base64(length: 32)
puts api_key_base64
# Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"

# With prefix for identification
versioned_key = ApiKeyGenerator.generate_with_prefix(prefix: "sk_live", length: 32)
puts versioned_key
# Output: "sk_live_p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"

package main

import (
    "crypto/rand"
    "encoding/base64"
    "encoding/hex"
    "fmt"
)

// GenerateAPIKey generates a hexadecimal API key
func GenerateAPIKey(length int) (string, error) {
    bytes := make([]byte, length)
    if _, err := rand.Read(bytes); err != nil {
        return "", fmt.Errorf("failed to generate API key: %w", err)
    }
    return hex.EncodeToString(bytes), nil
}

// GenerateAPIKeyBase64 generates a base64 URL-safe API key
func GenerateAPIKeyBase64(length int) (string, error) {
    bytes := make([]byte, length)
    if _, err := rand.Read(bytes); err != nil {
        return "", fmt.Errorf("failed to generate API key: %w", err)
    }
    return base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(bytes), nil
}

func main() {
    // Generate 256-bit (32 byte) API key
    apiKey, err := GenerateAPIKey(32)
    if err != nil {
        panic(err)
    }
    fmt.Println("Hex:", apiKey)
    // Output: "a7f3e9c2d8b4f1a6e5c9d7b3f8a2e6c4d9b5f7a3e8c6d2b9f4a7e1c5d8b3f6a9"

    // Base64 URL-safe encoding
    apiKeyBase64, err := GenerateAPIKeyBase64(32)
    if err != nil {
        panic(err)
    }
    fmt.Println("Base64:", apiKeyBase64)
    // Output: "p3_pwr2L8RpuXJbT-IouaztX86jG0rmU9KfhxdizNpo"
}