Secret key generator

const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

function apiKey(length = 32) {
  const n = ALPHABET.length;                  // 62
  const limit = Math.floor(2 ** 32 / n) * n;  // discard at or above this
  const buf = new Uint32Array(length);
  crypto.getRandomValues(buf);
  let out = "";
  for (let i = 0; i < length; i++) {
    let v = buf[i];
    while (v >= limit) v = crypto.getRandomValues(new Uint32Array(1))[0];
    out += ALPHABET[v % n];
  }
  return out;
}

"sk_live_" + apiKey();

Mapping raw bytes onto 62 symbols with a bare % is where modulo bias gets introduced. The discard loop is what removes it, and at 62 symbols it fires roughly once in a billion draws.

import secrets, string

# token_urlsafe(n) takes a BYTE count, not a character count.
secrets.token_urlsafe(32)   # 32 bytes -> 256 bits -> 43 characters
secrets.token_hex(16)       # 16 bytes -> 128 bits -> 32 characters

# Exactly 32 base62 characters. choice() is backed by randbelow(),
# which rejects out-of-range draws instead of taking a modulo.
ALPHABET = string.ascii_letters + string.digits
"".join(secrets.choice(ALPHABET) for _ in range(32))

The random module is a Mersenne Twister and its internal state is recoverable from its output. It must never appear in this code path.

import (
    "crypto/rand"
    "encoding/base64"
    "math/big"
)

// 32 random bytes as base64url with no padding: 43 characters, 256 bits.
b := make([]byte, 32)
rand.Read(b)
token := base64.RawURLEncoding.EncodeToString(b)

// Exactly 32 base62 characters.
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
out := make([]byte, 32)
for i := range out {
    n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(alphabet))))
    out[i] = alphabet[n.Int64()]
}

crypto/rand, never math/rand. rand.Int is already unbiased; it rejects internally so you do not have to.

// rand = "0.9"
use rand::distr::{Alphanumeric, SampleString};

// 32 characters of A-Za-z0-9 from the thread CSPRNG (ChaCha12,
// seeded from the operating system and reseeded periodically).
let key = Alphanumeric.sample_string(&mut rand::rng(), 32);

// Raw bytes straight from the OS, for when the value is a key rather
// than a printable token. In rand 0.9 OsRng is fallible, so it offers
// try_fill_bytes rather than fill_bytes.
use rand::rngs::OsRng;
use rand::TryRngCore;
let mut k = [0u8; 32];
OsRng.try_fill_bytes(&mut k).expect("OS RNG unavailable");

// 32 bytes as hex: 64 characters, 256 bits.
bin2hex(random_bytes(32));

// base64url, padding stripped: 43 characters.
rtrim(strtr(base64_encode(random_bytes(32)), '+/', '-_'), '=');

// Exactly 32 base62 characters. random_int() is unbiased.
$alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$key = '';
for ($i = 0; $i < 32; $i++) {
    $key .= $alphabet[random_int(0, strlen($alphabet) - 1)];
}

random_bytes() and random_int() throw when the platform cannot supply entropy. mt_rand() and rand() return something wrong instead, which is why they are unusable here.

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

SecureRandom rng = new SecureRandom();

byte[] raw = new byte[32];
rng.nextBytes(raw);
String token = Base64.getUrlEncoder().withoutPadding().encodeToString(raw);

// Exactly 32 base62 characters. nextInt(bound) is unbiased.
String ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
StringBuilder sb = new StringBuilder(32);
for (int i = 0; i < 32; i++) {
    sb.append(ALPHABET.charAt(rng.nextInt(ALPHABET.length())));
}

using System.Security.Cryptography;

// 32 bytes as base64url with no padding.
byte[] raw = RandomNumberGenerator.GetBytes(32);
string token = Convert.ToBase64String(raw)
    .TrimEnd('=').Replace('+', '-').Replace('/', '_');

// Exactly 32 base62 characters. GetString rejects internally. .NET 8 and later.
const string Alphabet =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
string key = RandomNumberGenerator.GetString(Alphabet, 32);

# 32 bytes as hex: 64 characters.
openssl rand -hex 32

# base64url, padding stripped: 43 characters.
openssl rand -base64 32 | tr '+/' '-_' | tr -d '='

# 32 base62 characters, straight from the kernel CSPRNG.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 32; echo

The tr pipeline discards every byte outside the alphabet rather than folding it back in, which is rejection sampling under another name, so the output is uniform.