Random String Generator — Free Online Tool

Generate cryptographically secure random strings for passwords, API keys, tokens. Custom length, character sets (letters, numbers, symbols). Bulk generation, export.

Use this free online Random String Generator directly in your browser. No signup required, no data leaves your device. Part of Utilier — a collection of 133+ developer utilities.

What is Random String Generator (Password, Token, Key)?

Random string generator creates cryptographically secure random strings for passwords, API keys, tokens, session IDs, or test data. Customize length (8-128+ characters) and character sets: uppercase letters (A-Z), lowercase (a-z), numbers (0-9), symbols (!@#$%^&*). Uses Web Crypto API (window.crypto.getRandomValues) for secure randomness (unpredictable, not guessable). Generate single strings or bulk (100s at once). Options include: exclude ambiguous characters (0/O, 1/I/l), custom character set, minimum requirements (at least 1 uppercase, 1 number, 1 symbol). Export as CSV, JSON, or plain text for use in code, databases, or spreadsheets.

Custom length: Set string length: 8-128+ characters. Example: 8 for weak password, 16 for strong, 32 for API key, 64 for token. Longer = more secure.
Character sets: Choose combinations: uppercase (A-Z), lowercase (a-z), numbers (0-9), symbols (!@#$%^&*()_+-=[]{}). Or use custom character set (hex: 0-9a-f, base64: A-Za-z0-9+/).
Exclude ambiguous: Option to exclude confusing characters: 0/O (zero/oh), 1/I/l (one/I/L), 5/S, 8/B. Improves readability for manual entry (passwords, license keys).
Minimum requirements: Enforce at least 1 uppercase, 1 lowercase, 1 number, 1 symbol (password policies). Regenerates until requirements met.
Bulk generation: Generate 1 to 1000+ strings at once. Useful for API keys, test data, or password lists. Export as CSV or JSON.

Why use random string?

Creating secure random strings manually is error-prone (weak passwords, predictable patterns). This tool generates cryptographically secure random strings instantly.

Secure passwords: Generate strong passwords (16+ chars, letters, numbers, symbols). Cryptographically secure (not guessable). Avoid weak passwords (password123, qwerty).
API keys and tokens: Create API keys (32-64 chars, hex or base64), session tokens, CSRF tokens, password reset tokens. Unpredictable = secure against brute force.
Avoid predictable patterns: Humans are bad at randomness (password1, abc123). Tool uses crypto randomness (truly random, not predictable).
Comply with password policies: Many sites require: 8+ chars, 1 uppercase, 1 lowercase, 1 number, 1 symbol. Tool enforces these rules automatically.
Bulk test data: Generate 100s of random strings for testing (user IDs, session IDs, test passwords). Export as CSV for databases or spreadsheets.
Custom character sets: Use hex (0-9a-f) for color codes, base64 (A-Za-z0-9+/) for encoding, or custom alphabet (consonants only, no vowels to avoid profanity).

When to use random string

Use whenever you need random strings for passwords, keys, tokens, or IDs.

Generating strong passwords (16+ chars, letters, numbers, symbols) for accounts or services.
Creating API keys (32-64 chars, hex or alphanumeric) for authentication.
Generating session IDs, CSRF tokens, or password reset tokens (unpredictable, secure).
Creating license keys or product keys (exclude ambiguous chars for readability).
Generating test data (random usernames, IDs, strings) for databases or testing.
Creating secrets for encryption keys, salts, or nonces (cryptographically secure).
Bulk generation of passwords or tokens (100+ at once) for user onboarding or testing.

How to use random string

Select options (length, character sets), click Generate.

Set string length: Enter length: 8-128+ characters. Example: 8 = weak, 16 = strong, 32 = API key, 64 = token. Longer = more secure.
Choose character sets: Select: Uppercase (A-Z), Lowercase (a-z), Numbers (0-9), Symbols (!@#$%^&*). Or use presets: Alphanumeric (A-Za-z0-9), Hex (0-9a-f), Base64 (A-Za-z0-9+/=).
Exclude ambiguous (optional): Exclude confusing characters: 0/O, 1/I/l, 5/S, 8/B. Improves readability for manual entry (license keys, passwords).
Set minimum requirements (optional): Enforce: at least 1 uppercase, 1 lowercase, 1 number, 1 symbol. Tool regenerates until requirements met (password policies).
Set quantity (optional): Generate 1 string (default) or bulk (10, 100, 1000). Useful for API keys, test data, or password lists.
Click Generate: Tool generates random strings using Web Crypto API. Results appear instantly (even for 1000 strings).
Copy or export: Copy to clipboard, download as CSV (for Excel), JSON (for code), or plain text (one per line). Use in spreadsheets, databases, or code.

Key features

Custom length: 8 to 128+ characters. Longer = more secure. 16+ recommended for passwords, 32+ for API keys.
Character sets: Uppercase, lowercase, numbers, symbols. Or presets: Alphanumeric, Hex, Base64. Or custom character set.
Exclude ambiguous: Remove 0/O, 1/I/l, 5/S, 8/B for readability. Useful for license keys or manual entry.
Password policies: Enforce minimum requirements: 1 uppercase, 1 lowercase, 1 number, 1 symbol. Meets common password rules.
Bulk generation: Generate 1 to 1000+ strings at once. Fast and efficient.
Cryptographically secure: Uses Web Crypto API (window.crypto.getRandomValues). Not predictable like Math.random().
Export formats: CSV, JSON, plain text. Copy or download. Use in Excel, databases, code.

Common use cases

Strong password (16 chars): Length: 16, Character sets: Uppercase, Lowercase, Numbers, Symbols, Minimum: 1 of each. Example: aB3$kL9mP2qR5tY8. Secure against brute force.
API key (32 chars, hex): Length: 32, Character set: Hex (0-9a-f). Example: 4f3a2b1c8e7d6a5b9c0d1e2f3a4b5c6d. Used for API authentication.
Session token (64 chars, base64): Length: 64, Character set: Base64 (A-Za-z0-9+/). Example: aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789+/aBcDeFgHiJkLmNoPqRsTuVwXyZ012. Used for session management.
License key (20 chars, no ambiguous): Length: 20, Character sets: Uppercase, Numbers, Exclude ambiguous: Yes. Example: A3K9P2R5T7W4X6Y8. Easy to read and type (no 0/O, 1/I).
CSRF token (32 chars): Length: 32, Character sets: Uppercase, Lowercase, Numbers. Example: aB3kL9mP2qR5tY8uV7xW4zA1bC6dE2fG. Used to prevent CSRF attacks.
Bulk passwords (100, 12 chars each): Quantity: 100, Length: 12, Character sets: All. Generates 100 passwords. Export as CSV for user onboarding or password manager.

Examples

Random string generation examples.

Strong password (16 chars)

Length: 16, Character sets: Uppercase, Lowercase, Numbers, Symbols

aB3$kL9mP2qR5tY8

16 characters with mixed case, numbers, symbols. Entropy: ~105 bits (very strong). Secure against brute force.

API key (32 chars, hex)

Length: 32, Character set: Hex (0-9a-f)

4f3a2b1c8e7d6a5b9c0d1e2f3a4b5c6d

Hexadecimal (0-9a-f). Used for API authentication, tokens, or database IDs. Entropy: 128 bits (cryptographically secure).

License key (20 chars, no ambiguous)

Length: 20, Character sets: Uppercase, Numbers, Exclude ambiguous: Yes

A3K9P2R5T7W4X6Y8Z2

No 0/O, 1/I/l, 5/S, 8/B. Easy to read and type manually. Used for software licenses or product keys.

Session token (64 chars, base64)

Length: 64, Character set: Base64 (A-Za-z0-9+/)

aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789+/aBcDeFgHiJkLmNoPqRsTuVwXyZ012

Base64 encoding alphabet. Used for session tokens, JWT, or encoding. Entropy: 384 bits (extremely strong).

CSRF token (32 chars)

Length: 32, Character sets: Uppercase, Lowercase, Numbers

aB3kL9mP2qR5tY8uV7xW4zA1bC6dE2fG

Alphanumeric (no symbols). Used for CSRF tokens, nonces, or challenge strings. Entropy: ~190 bits.

Technical reference

Random string generation specifications:

Algorithm: Uses Web Crypto API (window.crypto.getRandomValues). Cryptographically secure random (CSPRNG). Generates random bytes, maps to character set using rejection sampling (uniform distribution).
Character sets: Uppercase: A-Z (26 chars), Lowercase: a-z (26 chars), Numbers: 0-9 (10 chars), Symbols: !@#$%^&*()_+-=[]{}|;:',.<>?/ (32 chars). Total: 94 chars (full set).
Length range: 8 to 128+ characters. Minimum 8 (weak), 12 (medium), 16+ (strong). API keys: 32-64 chars. Tokens: 64-128 chars.
Ambiguous characters: Excluded when enabled: 0 (zero), O (oh), 1 (one), I (capital i), l (lowercase L), 5, S, 8, B. Reduces confusion for manual entry.
Password policies: Minimum requirements: at least 1 uppercase, 1 lowercase, 1 number, 1 symbol. Tool regenerates until requirements met (max 100 attempts, then fails with error).
Entropy calculation: Entropy = log2(charset_size^length). Example: 16 chars, 94-char set = log2(94^16) = 105 bits. 128+ bits = cryptographically strong.
Bulk generation: 1 to 1000+ strings. Browser limit ~10,000 (memory). For huge lists (1M+), use server-side generation.
Export formats: CSV (comma-separated, quoted), JSON (array of strings), plain text (one per line). Copy or download.
Math.random vs Crypto: Math.random() = pseudo-random (predictable). Crypto.getRandomValues = cryptographically secure (unpredictable). Always use Crypto for passwords/keys.
Browser support: Web Crypto API supported in all modern browsers (Chrome, Firefox, Safari, Edge). IE 11+ (with msCrypto fallback).

Common mistakes to avoid

Using Math.random() instead of crypto.getRandomValues() for passwords or keys

Why it happens: Math.random() is pseudo-random (predictable with seed knowledge). Attackers can predict output if they know seed or previous values. Not suitable for passwords, API keys, tokens. Common in old tutorials or quick hacks.

How to avoid it: Use window.crypto.getRandomValues (Web Crypto API) for security. Example: crypto.getRandomValues(new Uint8Array(16)). Cryptographically secure (unpredictable). NEVER use Math.random for passwords.

Creating short passwords (<12 chars), making brute force easy

Why it happens: 8-char password with 94-char set = 52 bits entropy (crackable in hours with GPU). 12-char = 78 bits (days), 16-char = 105 bits (centuries). Shorter = easier to crack.

How to avoid it: Use 16+ characters for passwords. 12 minimum for medium security. 8 is too weak (even with symbols). Longer = exponentially harder to crack.

Not excluding ambiguous characters (0/O, 1/I/l) for manual entry

Why it happens: Users confuse 0 (zero) and O (oh), 1 (one) and I/l (capital i, lowercase L). Causes login failures, support tickets, frustration. Common in license keys or passwords typed manually.

How to avoid it: Enable 'Exclude ambiguous' option for strings users must type (license keys, temporary passwords). For API keys (copy-paste), include all characters for more entropy.

Not enforcing password policies (1 uppercase, 1 number, 1 symbol), causing rejected passwords

Why it happens: Random generation may produce 'aaaaaaaaaaaaaaaa' (all lowercase, no numbers/symbols). Some sites reject this. User regenerates manually (annoying). Common when not checking requirements.

How to avoid it: Enable 'Minimum requirements' option: at least 1 uppercase, 1 lowercase, 1 number, 1 symbol. Tool regenerates until requirements met. Ensures compliance with password policies.

Storing passwords in plain text instead of hashing

Why it happens: This tool generates passwords, but you must hash them before storing (bcrypt, Argon2, PBKDF2). Storing plain text = security disaster (data breach exposes all passwords). Common beginner mistake.

How to avoid it: Hash passwords before storing: bcrypt.hash(password, 12). Never store plain text. Use password managers (1Password, Bitwarden) for personal use. For apps, hash with bcrypt/Argon2.

Frequently asked questions

What is the difference between Math.random() and crypto.getRandomValues()?

Math.random() = pseudo-random (predictable with seed, not secure). crypto.getRandomValues() = cryptographically secure (unpredictable, secure for passwords/keys). Always use crypto for security.

How long should my password be?

16+ characters for strong security. 12 minimum for medium. 8 is too weak (even with symbols). Longer = exponentially harder to crack. Use password manager for 32+ char passwords.

What are ambiguous characters and should I exclude them?

Ambiguous: 0/O (zero/oh), 1/I/l (one/I/L), 5/S, 8/B. Exclude for manual entry (license keys, temp passwords). Include for API keys (copy-paste, more entropy).

How do I generate API keys or tokens?

Use 32-64 characters, Hex (0-9a-f) or Base64 (A-Za-z0-9+/). Example: 32-char hex = 128 bits entropy (secure). For JWT, use 64-char base64 = 384 bits (very secure).

Can I enforce password policies (1 uppercase, 1 number, 1 symbol)?

Yes. Enable 'Minimum requirements' option. Tool regenerates until requirements met (at least 1 uppercase, 1 lowercase, 1 number, 1 symbol). Ensures compliance with password policies.

Is this random enough for cryptography or security?

Yes. Uses window.crypto.getRandomValues (Web Crypto API), which is cryptographically secure. Suitable for passwords, API keys, tokens, session IDs. NOT Math.random (not secure).

How do I export random strings to a file?

Click Export → CSV/JSON/Text. Download file or copy to clipboard. CSV for Excel, JSON for code, Text for plain lists. Useful for bulk passwords or API keys.

References

Privacy and availability

Runs entirely in your browser — zero server processing
No signup or account required
Works offline once loaded
Fast, lightweight, no external dependencies
Available as a browser extension for Chrome and Firefox

All developer tools

JSON Beautifier & Validator — Format, minify and validate JSON. Reports the exact error location.
HTML Beautifier & Minifier — Indent or minify HTML. Content of pre/script/style is preserved.
CSS Beautifier & Minifier — Pretty-print or minify CSS. Handles comments, strings, and nested at-rules.
JavaScript Beautifier & Minifier — Format, minify, or obfuscate JavaScript. String, template, regex and comment aware.
SQL Formatter — Format SQL queries: clauses on new lines, keywords uppercased.
SQL Converter — Convert SQL INSERT statements or SELECT results to CSV, JSON, XML, YAML, or HTML.
Markdown Preview — Live GitHub-flavoured-ish Markdown rendering (safe, HTML-escaped).
Diff Checker — Compare two texts line by line with additions and deletions highlighted.
Base64 / Base32 / Base58 / Base85 Encoder — Encode and decode text using Base64, Base32, Base58, Base85, or ASCII85.
URL Encode / Decode — Percent-encode or decode text and query components, in any character set.
HTML Entity Encode / Decode — Escape/unescape HTML special characters and numeric entities.
ROT13 / ROT-N Encoder — Apply the ROT13 letter cipher (or any ROT-N shift) to text. ROT13 is its own inverse.
JWT Decoder — Decode a JWT's header and payload. Optionally verify an HMAC signature.
JWT Generator — Create a signed JWT (HS256/384/512) from a JSON payload and secret.
Hash Generator — Compute MD5, SHA-1, SHA-256, SHA-384, SHA-512, and CRC-16 digests of text.
HMAC Generator — Compute a keyed HMAC signature of a message (SHA-1/256/384/512).
CRC32 Generator — Compute the CRC-32 (IEEE 802.3) checksum of text, shown as hex and decimal.
Hash Verification — Compute a hash of your text (MD5, SHA-1/256/384/512 or CRC-32) and compare it against an expected value to confirm a match.
Checksum Calculator — Upload a file to compute its SHA-1, SHA-256, SHA-384, SHA-512 and CRC-32 checksums for integrity verification.
Text Compression — Compress and decompress text using GZip, Deflate, or Deflate-Raw algorithms.
BCrypt Generator — Hash a password with bcrypt (Blowfish-based, salted) at a configurable cost, or verify a password against an existing bcrypt hash.
AES Encrypt / Decrypt — Encrypt or decrypt text with AES-256-GCM using a password (PBKDF2-SHA256 key derivation). Output is base64 packing salt + IV + ciphertext.
RSA Encrypt / Decrypt — Generate an RSA keypair and encrypt/decrypt short messages with RSA-OAEP (SHA-256). Keys are PEM. Best for small payloads (≈190 bytes at 2048-bit).
UUID Generator — Generate cryptographically-random version 4 UUIDs in bulk.
Password Generator — Generate strong random passwords with configurable character sets.
Regex Tester — Test JavaScript regular expressions with live match highlighting and groups.
Unix Timestamp Converter — Convert between Unix timestamps and human-readable dates (local & UTC).
Timezone Converter — Convert a date and time between any two IANA time zones (DST-aware).
Date Difference Calculator — Calculate the elapsed time between two dates as a calendar breakdown and in total units.
QR Code Generator — Turn text/URLs into a QR code, optionally with a centered logo. Download as PNG.
Color Picker & Converter — Convert between HEX, RGB(A), HSL(A), HSV, and CMYK. Pick a color visually.
cURL Converter — Convert a curl command to fetch, Axios, React, Python, Go, PHP, Java or Rust — and fetch back to curl.
JSON ↔ YAML — Convert JSON to YAML and YAML back to JSON.
TOML Converter — Convert TOML to JSON or YAML and JSON/YAML back to TOML, with validation.
JSON ↔ CSV / SQL — Convert JSON array to CSV, TSV, or SQL INSERT statements. Parse CSV/TSV back to JSON.
Lorem Ipsum Generator — Generate placeholder text by paragraphs, sentences or words.
Case Converter — Convert text between camelCase, snake_case, kebab-case, Title Case and more.
Number Base Converter — Convert integers between binary, octal, decimal, hexadecimal, and custom bases (radix 2-36).
Text / Binary / Hex / Decimal / Octal Converter — Convert between text, binary, hexadecimal, decimal, and octal. Auto-detects the input format.
Slug Generator — Convert titles into clean, URL-friendly slugs. Strips accents and punctuation.
CSS Unit Converter — Convert between px, rem, em, %, pt, pc, in, cm, mm, vw and vh.
Image Converter — Turn an image into a Base64 data URI, CSS background, <img> tag or an SVG wrapper.
Unicode Encoder / Decoder — Convert text to and from \uXXXX escapes, or list its Unicode code points.
UTF-8 Encoder / Decoder — Convert text to its UTF-8 bytes (hex, decimal or binary) and decode bytes back to text.
ASCII Converter — Convert text to and from character codes in decimal, hexadecimal or binary.
Escape / Unescape — Escape and unescape strings for JSON, XML, JavaScript, CSV, and SQL contexts.
Word & Character Counter — Live count of words, characters, lines, sentences, paragraphs and reading time.
Text Formatter & Cleaner — Clean up text: remove blank lines, trim spaces, strip line numbers, sort/shuffle/reverse lines or words, remove punctuation, flip upside down.
Advanced String Tools — Advanced string manipulation: remove accents, extract delimited text, filter lines, calculate similarity, character diff.
Emoji Picker — Browse and click an emoji to copy it to your clipboard.
Nano ID Generator — Generate compact, URL-safe unique IDs with a configurable size and alphabet.
ULID Generator — Generate ULIDs — 128-bit, lexicographically sortable IDs (48-bit time + 80-bit randomness) in Crockford Base32, with an optional monotonic mode.
UUID Validator — Check whether a string is a valid UUID and detect its version and variant.
Random Number Generator — Generate cryptographically-random integers, decimals, primes, or fractions within a range.
Random String Generator — Generate random strings from selectable character sets, or special formats (hex, binary, MAC address).
Random Regex Generator — Generate random strings that match a regular expression pattern. Perfect for test data generation.
ASCII Art Generator — Turn text into a figlet-style banner or convert an image into ASCII art. Copy, download as text or image, and share.
Snowflake ID Generator — Generate and decode Twitter/Discord-style Snowflake IDs with a configurable epoch and bit layout.
CSS Gradient Generator — Design linear or radial gradients with live preview and copy the CSS.
Box Shadow Generator — Visually build a CSS box-shadow and copy the rule.
CSS Grid & Flexbox Generator — Generate CSS Grid templates or Flexbox layouts with a live preview, then copy or download the CSS.
Query Parameter Parser — Break a URL or query string into its individual parameters.
Query String Builder — Assemble a URL-encoded query string from key/value pairs.
robots.txt Generator — Generate a robots.txt with allow/disallow rules, crawl-delay and sitemap.
sitemap.xml Generator — Turn a list of URLs into a valid XML sitemap.
.gitignore Generator — Combine common .gitignore presets for languages, OSes and editors.
Dockerfile Generator — Scaffold a Dockerfile for many stacks with multi-stage builds, env vars, ports, a non-root user and healthcheck.
.htaccess Generator — Generate common Apache .htaccess rules (HTTPS, www, caching, compression).
Server Config Generator — Generate nginx, Apache or Tomcat configs for HTTPS, reverse proxy, load balancing, API gateway, caching and rate limiting.
XML Beautifier / Minifier — Pretty-print, minify, validate XML. Convert to JSON or CSV.
Cron Expression Parser — Translate a cron expression into a plain-English schedule.
Cron Expression Generator — Build a cron expression from simple schedule fields with a live description.
Regex Generator — Pick a common validation pattern and test it against sample text.
CIDR Calculator — Expand an IPv4 CIDR block into network, broadcast, host range and mask.
Subnet Calculator — Enter an IP and a subnet mask (dotted or prefix) to compute the subnet details.
IP Address Converter — Convert IPv4 addresses to and from decimal, hexadecimal, octal, and binary formats.
Punycode Converter — Convert internationalized domain names (IDN) to and from Punycode (xn--) ASCII form.
CSP Generator & Evaluator — Build a Content-Security-Policy from directives and lint any pasted CSP for common weaknesses.
Kubernetes Manifest Generator — Generate a Kubernetes Deployment + Service manifest (image, replicas, ports, env vars) as YAML.
Docker Compose Generator — Build a docker-compose.yml with a primary service plus optional Postgres, MySQL, Redis or Mongo add-ons.
Terraform (AWS) Generator — Generate Terraform HCL for common AWS resources: EC2 instance, S3 bucket or security group.
GitHub Actions Generator — Generate a CI workflow (.github/workflows/ci.yml) for Node, Python, Go, Java or Rust with push/PR triggers.
AWS IAM Policy Generator — Generate AWS IAM policy JSON documents with common actions for S3, EC2, Lambda, DynamoDB, and more.
GitLab CI Generator — Generate .gitlab-ci.yml pipeline configurations for Node.js, Python, Docker, Terraform, and Go projects.
Nginx Config Generator — Generate production-ready Nginx server blocks for reverse proxy, SPA, or static sites with SSL, gzip, and security headers.
SSL/TLS Certificate Decoder — Decode PEM-encoded X.509 certificates — view subject, issuer, validity, SAN, and expiration status.
Helm Chart Generator — Generate Kubernetes Helm chart scaffolding (Chart.yaml, values.yaml, deployment template) with configurable options.
Dockerfile Linter — Lint Dockerfiles offline — checks for best practices like pinned tags, apt cleanup, COPY vs ADD, exec-form CMD, and more.
Terraform Backend Config — Generate Terraform backend configuration for S3, GCS, Azure, Consul, or local state storage with provider setup.
Kubernetes Policy Checker — Analyze Kubernetes YAML offline for risky security settings, mutable images, missing resources, and production-readiness gaps.
Terraform Static Analyzer — Scan Terraform HCL offline for risky AWS patterns such as public admin ingress, unencrypted storage, missing provider pins, and static credentials.
IAM Policy Risk Analyzer — Review AWS IAM policy JSON offline for wildcard permissions, broad resources, escalation-sensitive actions, and risky trust patterns.
Architecture Diagram Generator — Create Mermaid architecture diagrams offline from service and dependency lists for system design, DevOps handoffs, and runbooks.
Incident Runbook Builder — Generate practical incident response runbooks offline with triage, diagnosis, rollback, communication, validation, and follow-up sections.
SLO Error Budget Calculator — Calculate availability, allowed downtime, error budget consumption, remaining budget, and burn rate for SRE and operations planning.
Image Resizer & Compressor — Crop, resize an image to exact pixel dimensions and re-encode it at a chosen quality to shrink the file size.
Image Cropper — Crop an image with a draggable, resizable selection box. Move it, drag any of the 8 handles, and lock to a fixed aspect ratio or crop freely.
SVG Viewer — Paste SVG markup to preview it live and export it as a data URI or PNG.
Barcode Generator — Generate a Code 128 barcode from text and export it as PNG.
Favicon Generator — Create favicon PNGs from a letter or emoji with custom colors, in every common size.
Fake Data Generator — Generate mock people or products (JSON/XML/CSV) or placeholder images (PNG/JPG/WEBP/GIF) for prototyping.
SQLite Viewer — Open a .sqlite/.db file in the browser, browse tables and run SQL — fully client-side.
Clipboard History — The last 10 things you copied from any tool. Click to copy again.
HTTP Status Codes — Searchable reference of HTTP response status codes with their names and meanings.
Keyboard Event Tester — Inspect key events (key, code, keyCode, modifiers) and browse the ASCII chart with code↔character conversion.
Developer Calculator — Evaluate math expressions with functions (sqrt, sin, cos, log), constants (pi, e), operators (^, %, /), and bitwise operations (and, or, xor, not, shl, shr).
OpenAPI / Swagger Viewer — Browse an OpenAPI/Swagger document's endpoints and schemas in a readable list — paste JSON or YAML, entirely offline.
OpenAPI to cURL Inspector — Convert OpenAPI/Swagger JSON operations into ready-to-run cURL request starters — a lightweight inspector, not a full spec browser.
JSON & HAR Secret Redactor — Redact likely secrets, authorization headers, and email addresses locally before sharing data.
SVG Optimizer & Inspector — Minify SVG markup locally and flag common preview and accessibility gaps.
Web Manifest Validator — Validate a PWA web manifest locally and inspect essential install metadata.
CSS Specificity Calculator — Compare CSS selectors locally and see the cascade specificity tuple.
Cookie Parser & Set-Cookie Builder — Parse Cookie and Set-Cookie values, then build a standards-friendly response header locally.
Unicode Security Inspector — Find invisible Unicode, bidi controls, mixed scripts, and common confusable characters locally.
Regex Extractor — Extract every regex match and capture group with locations, then export JSON or CSV locally.
Cron Expression Explainer — Explain five-field cron schedules and preview the next 10 runs in a selected timezone.
CSS clamp() Fluid Scale Generator — Generate a responsive CSS clamp() value from minimum and maximum viewport and size targets.
Unit Converter — Convert between units of length, weight, temperature, area, volume, speed, time, data size, and pressure.
JSONPath Query — Query JSON data using JSONPath expressions ($, dot notation, arrays, wildcards, recursive descent).
HTML ↔ Markdown Converter — Convert HTML to Markdown and Markdown to HTML. Handles headings, lists, tables, links, images, and code blocks.
HAR File Analyzer — Inspect a browser HAR capture locally: slow requests, failures, domains, and transfer size.
.env Parser & Converter — Validate environment variables locally and convert .env entries to JSON or Docker Compose YAML.
JSON Schema Validator — Validate JSON locally against a practical JSON Schema subset and see precise field-level errors.
HTTP Header Analyzer — Parse HTTP headers locally and identify caching, CORS, cookie, and security-header concerns.
Cheat Sheets — Instant-search reference cards for git, docker, kubectl, terraform, vim, bash, and regex. Click any command to copy.
Kubernetes YAML Generator — GUI wizard to generate production-ready Kubernetes manifests: Deployment, Service, Ingress, ConfigMap, Secret, PVC, HPA.
Markdown Writer — Write markdown with a quick-action toolbar. Preview as rendered HTML, copy or download in multiple formats.
API Tester — Lightweight REST, GraphQL & WebSocket client with auth, body types, query params, and request history.
JSON to TypeScript — Convert JSON objects to TypeScript interfaces. Handles nested objects, arrays, and optional/null fields.
CSS Animation Generator — Create CSS animations with live preview. Adjust timing, pick presets, upload an image to test. Copy the generated CSS.
Image ↔ Base64 — Convert images to Base64 data URIs, or paste a data URI to preview and download the image. Max 2MB.
HTML Table Generator — Visual table builder — set rows and columns, fill in data, generate clean HTML table code.
Credit Card Validator — Validate card numbers using the Luhn algorithm. Identifies card type (Visa, Mastercard, Amex, Discover, etc.).