Developer Tools

Beautify, minify, escape or tree-view JSON; repair broken JSON; flatten/unflatten nested objects; generate JSON Schema; validate data against a JSON Schema; convert between JSON and YAML, XML, a query string, or a Markdown table; generate TypeScript interfaces or C# POCO classes; compare two JSON documents; query with JSONPath or JSONata expressions. Bidirectional CSV, TSV and JSONL conversion. Also includes a Package.json Inspector to analyse npm dependencies, scripts, and issues.

Beautify, minify, extract text or convert to HTML divs, or escape entities — all as format modes; bidirectional XML↔JSON live sync; convert to/from YAML, CSV, an HTML table, or a Markdown table; inspect nested element structure with syntax highlighting; evaluate XPath expressions; validate against an XSD schema or a DTD.

Format SQL queries; visually build SELECT statements; inject parameters; convert between dialects; visualize schema; export INSERT statements to JSON, CSV, XML, YAML, or HTML; generate C# migration classes for EF Core, FluentMigrator, or DbUp; lint for anti-patterns; get index suggestions; look up dialect syntax; generate ORM models; estimate query cost; and simulate transaction isolation levels.

Beautify or minify HTML; encode/decode HTML entities; strip tags; sanitize markup; extract inline CSS; HTML↔Markdown; Markdown Table generator; HTML↔BBCode; Word→HTML; HTML↔PUG; HTML→PHP; bidirectional HTML table↔CSV/JSON/XML/YAML; inline CSS for email; convert HTML to React/Vue/Angular components.

Format CSS; convert between px/rem/em/vw units; build gradients, box shadows, flexbox and grid layouts, border radii, transitions, and CSS filters — all with live preview.

Prettify, minify, or fully compile LESS stylesheets to real CSS via less.js (variables, parameterized mixins, functions, operations, and nesting all resolved). Configurable indentation, comment stripping, and blank lines between rules.

Prettify, minify, or fully compile SCSS/Sass stylesheets to real CSS via dart-sass ($variables, @mixin/@include, functions, @extend, and nesting all resolved). Configurable indentation, comment stripping, and blank lines between rules.

Beautify or minify JavaScript; convert ESM↔CJS modules; check JS syntax; obfuscate JavaScript code.

Beautify Lua scripts: configurable indentation, configurable string quoting, live preview.

Normalize and prettify Markdown documents: ensure blank lines before headings and fenced code blocks, normalize list markers to -, trim trailing whitespace, and collapse excess blank lines. Live HTML preview via marked.

Beautify or minify TypeScript code using js-beautify; configure indentation, brace style, and newline preservation; string-safe minifier that strips comments without mangling string content.

Beautify or minify React JSX and TSX code; uses js-beautify with e4x mode for proper JSX tag formatting; configure indentation and newline preservation.

Beautify or minify Angular TypeScript files — components, services, directives, pipes, and modules. Uses js-beautify with Angular-specific examples; configure indentation and brace style.

Beautify and validate YAML documents; spot structural errors, bad indentation, and duplicate keys; convert to/from TOML, JSON, XML, or CSV/TSV; merge multiple files; resolve anchors, aliases, and merge keys; query with dot-path expressions; validate data against a JSON Schema.

Universal data format converter — auto-detects JSON, YAML, XML, TOML, CSV, TSV, or SQL INSERT rows and lets you override the guess, then converts between any of them, chaining through an intermediate format when no direct conversion exists (e.g. TOML → YAML → XML). Also generates one-way code — C#/TypeScript from JSON, and ORM models or C# migrations from a SQL CREATE TABLE schema.

Format, minify, and validate GraphQL schemas and queries; convert SDL ↔ TypeScript, infer SDL from JSON; generate mock data from SDL types; inline fragment spreads; browse introspection schemas.

Format TOML, INI/.env, Nginx (with linting), HCL/Terraform; convert TOML ↔ JSON ↔ YAML; validate Docker Compose files and convert them to Kubernetes manifests; lint or visually build GitHub Actions workflows; generate .htaccess rules; inspect Helm values.yaml for hardcoded secrets.

Encode and decode Base64, Base32 (RFC 4648), Base58 (Bitcoin alphabet), and Base85/Ascii85; convert JSON, XML, YAML, CSV, and other formats to and from Base64; encode/decode Quoted-Printable (MIME).

Encode or decode URL-encoded strings and query parameters; supports standard percent-encoding, form encoding, and full URI component mode.

Convert integers between decimal, binary, hex, and octal; calculate percentages; evaluate math expressions; convert numbers to words; Roman numerals; bitwise operations; matrix operations; IEEE 754 visualizer; descriptive statistics; combinatorics (factorial/permutations/combinations); arbitrary-precision big number calculator.

Inspect every Unicode code point in a string: see name, block, category, and hex value; normalize strings; pick characters; detect visually confusable characters; convert to/from \uXXXX, %uXXXX, and HTML-entity escape sequences; convert between emoji and GitHub/Slack :shortcode: names.

Comprehensive measurement converter: length, mass, volume, area, speed, temperature, pressure, energy, data, angle, data transfer rate — Screen PPI calculator, paper size/aspect ratio solver, cooking unit converter, live currency conversion — and custom unit definitions.

Enter a date and time in any timezone and see the equivalent time in multiple target timezones simultaneously; add or remove zones dynamically; meeting planner; world clock.

Live clock with week number and day-of-year; convert Unix timestamps or date strings in any timezone; date difference, age calculator, working days, duration, DST viewer.

Upload Excel (.xlsx/.xls/.ods) or CSV files and convert to JSON, CSV, XML, or HTML; export JSON or CSV data to a downloadable .xlsx file — fully client-side using SheetJS.

Text analysis (stats + word frequency + word cloud), case conversion with URL slug generation, escape/unescape, Lorem Ipsum, random strings, ROT13, Morse code, NATO phonetic, extract emails/URLs/IPv4+IPv6 addresses, sort lines, remove duplicates, anagram, type converter, column aligner, readability.

Test regular expressions against any input with live match highlighting; see capture groups, match indices, match count, and replacement output as you type. Visualize patterns as railroad diagrams, get token-by-token explanations, check for catastrophic-backtracking (ReDoS) risk, and browse a curated pattern library.

Compare two text blocks side-by-side with color-coded line-by-line differences; apply or generate unified diff patches; load files via drag-and-drop; word-level and JSON-aware modes.

Semantic, structure-aware diffing for API and schema documents — reports meaningful changes like endpoints added/removed/changed and fields added/removed, not raw text lines. Covers OpenAPI specs, GraphQL SDL, JSON Schema documents, and SQL DDL (CREATE TABLE) scripts.

Convert between CSV, TSV, JSON, YAML, SQL, XML, HTML tables, query strings, and Markdown tables; redelimit between any separators; join two tables on a key column; pivot/summarize rows by group with sum/avg/count/min/max; build charts; edit inline in a spreadsheet grid; per-column statistics; CSV validator.

Generate UUIDs in v1, v3, v4, v5, v7 formats; generate ULIDs and NanoIDs; validate and decode any UUID — detect version, variant, timestamp, clock sequence, and node.

Hash text or files using MD5, SHA-1, SHA-256, SHA-384, SHA-512, and other algorithms; identify unknown hash types; compare two inputs to verify identical digests.

Generate QR codes and 1D/2D barcodes (Code 128, EAN-13, UPC-A, ITF, and more) from any text or URL; customize size and colors; download as PNG or SVG; batch generate.

Generate realistic fake names, addresses, phone numbers, emails, company data, and more; useful for populating test databases and UI prototypes. Export as JSON, CSV, SQL INSERT, or TypeScript typed array.

Generate cryptographically random integers, decimals, strings, hex, bytes, UUIDs, IP addresses, MAC addresses, dates, prime numbers, and more — all client-side using crypto.getRandomValues(). Also flip a coin or roll dice (with hold/reroll for Yahtzee-style play).

Generate HTML meta tags for SEO, Open Graph (Facebook, LinkedIn), and Twitter Card social sharing; fill in title, description, image, and other properties to get a ready-to-paste snippet.

Fill in project details and generate a well-structured README.md scaffold with badges, installation instructions, features, contributing guide, and license section.

Build a robots.txt file visually: configure User-agent rules, Allow/Disallow paths, Crawl-delay, and Sitemap URL. Also checks an existing robots.txt against 16 known AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended, and more) to show which are allowed or blocked.

Generate a sitemap.xml from a list of URLs; configure lastmod, changefreq, and priority per URL. Download or copy the result.

Paste conventional commit messages to generate a formatted CHANGELOG.md section with grouped sections for Added, Fixed, Changed, and Breaking Changes.

Generate a web app manifest (manifest.json) for your Progressive Web App. Configure name, icons, display mode, theme color, start URL, and more. Copy or download the result.

Generate a customizable privacy policy for your SaaS, app, or website. Supports GDPR, CCPA, PIPEDA and more; configure data types, third parties, retention period, and security measures.

Generate a customizable Terms of Service starter template for your website or app. Configure company/site details, jurisdiction, and toggleable sections like user accounts, payments, IP ownership, liability, and arbitration.

Build a self-contained cookie consent banner: configurable cookie categories, banner text, position/style, and colors, with a live sandboxed preview and a copy/download-ready HTML+CSS+JS snippet that persists consent in localStorage and exposes it via window.getCookieConsent() and a cookieconsentchanged event.

Build an RFC 9116 security.txt file: configure Contact, Expires, Encryption, Acknowledgments, Preferred-Languages, Canonical, Policy, and Hiring fields, with live preview and download. Also parses an existing security.txt back into the form.

Build an llms.txt file — a curated Markdown summary of your site for LLMs: title, one-line summary, optional longer description, and repeatable link sections (e.g. Docs, Examples, Optional). Live preview, download, and parses an existing llms.txt back into the form.

Build schema.org JSON-LD structured data for Articles, Products, FAQs, Recipes, Events, and Organizations — ready to paste into your page's <head>.

Decode JSON Web Tokens and inspect the header, payload, and signature claims; encode new tokens; view JWKS; reference standard claims; verify signatures; run security tests.

Generate strong random passwords with configurable length, character sets, and exclusion rules; create memorable passphrases; check password strength; hash passwords with bcrypt/Argon2.

AES-256-GCM encrypt/decrypt text or files with PBKDF2 key derivation; RSA-OAEP key pair generation, encryption, and decryption; SHA hashing with batch mode — all in-browser via Web Crypto API. Files never leave your device.

Generate Time-based One-Time Passwords (RFC 6238) from a Base32 secret key; shows current, previous, and next codes with a QR code and countdown timer; supports SHA-1, SHA-256, SHA-512 algorithms.

Generate RSA-2048, RSA-4096, ECDSA P-256, and ECDSA P-384 SSH keypairs entirely in-browser using the Web Crypto API. Export private key as PKCS#8 PEM and public key in OpenSSH format.

Generate and validate BIP39 mnemonic seed phrases (12-24 words), view the underlying entropy, and derive the BIP32 master seed — with an optional passphrase. All client-side, nothing is sent anywhere.

Create and get passkey/WebAuthn credentials against the real browser API, then decode clientDataJSON, authenticatorData flags/signCount, and the CBOR-encoded attestationObject/COSE public key. Also decodes pasted base64url data without a live authenticator.

Encrypt, decrypt, sign and verify messages using OpenPGP.js. Generate ECC or RSA keypairs, encrypt to a public key, decrypt with passphrase, and create or verify cleartext signatures — all in-browser.

Decode and inspect SAML 2.0 Responses, Assertions, and AuthnRequests — paste raw XML or base64-encoded tokens. Displays issuer, subject, conditions (with expiry check), attributes table, authn context, and signature info.

Compute SHA-1, SHA-256, SHA-384, and SHA-512 cryptographic hashes of any file entirely in-browser using the Web Crypto API — nothing is uploaded; supports drag-and-drop and hash verification.

Generate PKCE code_verifier and code_challenge pairs, build a full authorization URL, decode and inspect JWT access tokens with expiry status, and follow the step-by-step Authorization Code + PKCE flow.

Look up TLS certificates for any domain via the public crt.sh certificate transparency log — no proxy or API key required.

Parse PEM-encoded X.509 certificates and display subject, issuer, validity period, SANs, public key algorithm, signature algorithm, and SHA fingerprints.

Decode DER/BER binary data (hex or Base64/PEM) into a readable ASN.1 tree with tag types, lengths, values, and OID resolution for common cryptographic identifiers.

Analyze security headers (HSTS, CSP, X-Frame-Options, etc.) for any URL using a public CORS proxy. Grades and recommendations included.

Visual builder for Content Security Policy headers. Enable and configure 18 directives; add source expressions as chips; get live warnings for unsafe-inline and unsafe-eval; copy the ready-to-use header string. Also includes an Evaluate mode to paste an existing CSP header and get a graded security report.

Build correct Access-Control-* response headers for any CORS configuration. Toggle methods, set allowed/exposed headers, enable credentials mode, and get nginx and Express.js code snippets.

Validate any credit card number using the Luhn algorithm and network prefix rules; generate test card numbers for Visa, Mastercard, Amex, Discover, and Diners Club.

Scan pasted text for accidentally-committed secrets — AWS keys, GitHub/Slack/Stripe/Google tokens, JWTs, and PEM private keys — entirely client-side. Nothing is sent anywhere.

Audit pasted HTML for common accessibility issues — missing alt text, unlabeled form inputs, heading hierarchy skips, missing lang attribute, ARIA misuse, non-semantic markup, and unreachable links — entirely client-side.

Look up ~25 common SPDX licenses (MIT, Apache-2.0, GPL-3.0-only, LGPL, BSD, MPL-2.0, AGPL, and more) to see their category, key obligations, and a plain-English summary; check whether two licenses are generally compatible and why — e.g. can a GPL-3.0 dependency be used in an MIT project.

Convert issue titles to valid GitLab branch names; generate .gitignore files; build and validate conventional commit messages; semver bumper and checker; Git hooks reference.

Parse any standard or extended cron expression and explain it in plain English; list the next N scheduled trigger times; build expressions visually; compare two schedules.

Set Unix file permissions interactively; numeric octal and symbolic notation; umask calculator; POSIX ACL reference.

Paste any shell command and get a plain-English explanation of every flag, option, and argument. Covers curl, git, docker, find, grep, awk, sed, ssh, rsync, tar, kubectl, npm, jq, openssl, terraform, and more.

Lint a GNU Makefile for the classic tab-vs-spaces "missing separator" mistake, duplicate target definitions, undefined variables and target references, and phony-looking targets missing from .PHONY; or generate a starter Makefile from a Node.js/Go/Generic preset with editable variables, .PHONY targets, and target dependencies — entirely client-side.

Generate systemd unit files with a form builder, and experiment with sed substitution and awk field-processing on live text, all client-side.

Visually build MongoDB find queries and Redis CLI commands, and inspect Prisma schema files for model fields, attributes, and relations — no database connection required.

Estimate token counts for any text with per-model cost breakdowns across OpenAI, Anthropic, Google, and more. Build multi-turn chat conversations and export as ready-to-run API request JSON for OpenAI, Anthropic, or Gemini. Visually build function/tool-calling JSON schemas for OpenAI or Anthropic tool use.

Visual color picker, format converter (HEX/RGB/HSL/HSV/CMYK), palette generator, WCAG contrast checker, CSS named color reference, color blindness simulator, gradient editor, palette extraction from images, and a curated gradient gallery.

Parse .env environment variable files; lists all key-value pairs; filter by key or value; export variables as JSON, shell export statements, or Docker -e flags; compare two .env files; validate required variables.

Lint a Dockerfile for best practices: pin image versions, avoid running as root, combine RUN layers, use --no-install-recommends, detect secrets in ENV, and more; generate a best-practice multi-stage Dockerfile for Node.js, Python, Go, .NET, Java, or static/Nginx sites; or build a docker-compose.yml visually from services, ports, volumes, and environment variables.

Validate Kubernetes manifests against built-in schema rules: required fields, apiVersion, container images, resource limits, liveness probes, and more. Supports 16 resource kinds. Also includes a Diff mode for semantically comparing two manifest versions.

Analyze an npm package-lock.json, yarn.lock, or pnpm-lock.yaml: total package count, duplicated package versions with who pulled in each, dev/prod split, registry breakdown, and the largest dependency subtree. All parsing happens client-side.

Generate a new OWIN Startup.cs by picking middleware (CORS, static files, cookie/OAuth authentication, Web API, SignalR, session, error page); or paste an existing OWIN Configuration(IAppBuilder app) method and migrate it to a .NET 6+ minimal-hosting Program.cs with a per-line breakdown of what changed. Includes a standalone OWIN → ASP.NET Core middleware reference table.

View and search structured log files (JSON Lines, Apache/Nginx access logs); highlight log levels and filter entries by time range, severity, or keyword; use regex search for advanced pattern matching.

Paste a raw stack trace from any runtime — Node.js, Python, Java, .NET, Go, Rust, PHP, or Ruby — and get a structured, colour-coded frame breakdown with file, function, and line details.

Displays the key code, key value, modifier flags, and physical location for every keyboard event you trigger; essential for debugging custom keyboard shortcuts.

Drop any file to view its raw bytes as a 16-column hex grid with ASCII decode panel; search for hex byte sequences; supports files up to 512 KB display.

Decode and encode CBOR (RFC 8949), MessagePack, BSON, or Avro binary data from hex or Base64 into readable JSON — and encode JSON back into binary. Avro encoding is schema-guided with support for records, arrays, maps, unions, and all primitive types.

Enter a 32-bit integer; define named bit-fields; live-decode all fields with visual binary display.

Parse .proto schemas; encode JSON to binary protobuf (shown as hex); decode binary back to JSON. Supports nested messages, repeated fields, and all scalar types.

Save, tag, and search reusable code snippets with syntax-highlighted display; export/import as JSON; stored locally in your browser.

Paste an AWS IAM policy JSON and understand what it grants. Highlights wildcards, detects admin access, identifies overly-permissive statements, and explains each statement in plain English.

Build styled terminal output strings using ANSI escape codes. Choose foreground/background colors (named, 256-color, or truecolor), apply bold, italic, underline. Preview live in a fake terminal.

Live window size indicator with framework breakpoint reference for Tailwind CSS, Bootstrap 5, Material UI, and Vuetify 3. Shows your current breakpoint in real time as you resize.

Enter a rough performance budget spec — total JS/CSS size, image count and average size, third-party script count, web fonts — against editable pass/warning thresholds based on common performance-budget guidance. Estimates which categories are likely to hurt LCP, TBT/INP, or CLS. A static budget-threshold estimator, not a real Lighthouse/CrUX measurement.

Search a curated list of ~45 common CSS properties and JavaScript/Web APIs (Flexbox, Grid, :has(), Container Queries, Fetch, WebSockets, IndexedDB, and more) and see which currently-relevant Chrome/Firefox/Safari/Edge versions support them, using real support data bundled from caniuse-lite and browserslist's own "last 5 versions" browser lists.

In-browser JavaScript console with persistent history, multi-line editing, async/await support, and a sandboxed iframe execution environment.

Compile TypeScript to JavaScript in-browser using the TS compiler loaded from CDN. Supports generics, classes, decorators, utility types; configurable target and module format.

Run real Python in your browser via Pyodide (CPython compiled to WebAssembly), executing inside a Web Worker so the page stays responsive. Write code, see stdout and the last expression's value, and use standard-library modules like math and json.

Live HTML + Tailwind CSS playground. Write HTML with Tailwind utility classes and see the result instantly in a preview pane.

Render Mermaid diagrams in real time — flowcharts, sequence diagrams, class diagrams, ER diagrams, Gantt charts, and pie charts; copy or download the rendered SVG.

Test Handlebars/Mustache template strings with a live JSON context — variables, conditionals, and loops.

Interactive, animated visualizations of core JavaScript runtime concepts — the event loop, promise chains, DOM event bubbling, and web storage.

Trace real recursive call stacks step by step, get a heuristic Big-O time complexity estimate for a function, and step through an LRU/LFU cache eviction simulator.

Step through classic data structures visually — sorting algorithms (Bubble, Insertion, Selection, Merge, Quick, Heap Sort), linked lists/stacks/queues, binary search trees, graph traversal (BFS/DFS/Dijkstra), and hash tables with chaining or open addressing.

Step through classic distributed-systems concepts visually — TLS 1.2/1.3 handshakes, consistent hashing with virtual nodes, rate limiter algorithms (Token Bucket, Leaky Bucket, Fixed Window, Sliding Window Log), load balancing strategies, vector clock / Lamport timestamp causality, and a real discrete-event Raft leader-election and log-replication simulator. All simulated client-side with no real network calls.

Visualize LINQ method chains step by step — paste a query, pick a dataset, and see each operator's output in an interactive pipeline. Supports Where, Select, OrderBy, GroupBy, Take, Skip, Count, Sum, Average, and more. All simulated client-side with no server round-trips.

Real execution against browser platform APIs — spawn a real Web Worker and message it, exercise Cache Storage strategies (Cache First, Network First, Stale-While-Revalidate) with the real CacheStorage API, run a local WebRTC loopback with live ICE candidates, connect to a Server-Sent Events endpoint, explore a WebAssembly module's exports, and try BroadcastChannel cross-tab messaging plus the Web Locks API.

Run real SQL against an in-browser SQLite database — genuine execution via sql.js (SQLite compiled to WebAssembly), not a simulator. Write schema/setup SQL, run queries and see real result sets or SQLite error messages, run EXPLAIN QUERY PLAN for real query plans, and browse live schema metadata via sqlite_master and PRAGMA introspection.

Define a finite state machine as JSON (states, transitions, guard expressions) and simulate it for real — fire events, evaluate guards against a live context object, and watch the current state highlighted on a live Graphviz diagram. A genuine interpreter, not a scripted animation.

Send HTTP requests (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS) directly from the browser; import a curl command to fill in method, URL, headers, auth, and body in one step; configure environment variables, auth presets, headers, query params, and body; includes a built-in WebSocket client.

Send real GraphQL queries and mutations to any endpoint directly from the browser, with custom headers (Bearer/API key auth), a JSON variables editor, and request timing; run live schema introspection against the same endpoint and browse the result as a searchable types → fields → arguments tree.

Three-in-one HTTP reference: all status codes (1xx–5xx) with reason phrases and use cases; MIME type lookup by extension or Content-Type string; and a comprehensive HTTP headers dictionary with direction, category, description, and usage examples.

Paste a raw HTTP request to parse method, path, HTTP version, query parameters, headers, and body; convert between cURL commands and JavaScript fetch() code in either direction; or convert a Postman/Insomnia collection to cURL commands or an OpenAPI skeleton.

Build a complete set of HTTP request headers by selecting from 30+ known header names with descriptions and common value suggestions. Generates formatted headers block, curl -H snippets, and JavaScript fetch object.

Parse HTTP Cookie request headers and Set-Cookie response headers into name/value pairs with URL-decoded values and all attributes (Path, Domain, Expires, SameSite, HttpOnly, Secure); build a Set-Cookie header from a form with live preview; or scan pasted HTML/cookies for known trackers (Google Analytics, Meta Pixel, Hotjar, Microsoft Clarity, and more).

Look up IP geolocation data; query DNS records via Cloudflare DoH; look up domain and IP registration data via RDAP. Test download speed and check if a URL is reachable.

Calculate IPv4 subnet details from CIDR notation: network address, broadcast, host range, subnet mask, wildcard mask, host count, and binary representation. Subnet splitter, VLSM, IPv6 support, and a CIDR aggregation/overlap checker.

Inspect IPv4 and IPv6 addresses; classify address type; convert between IP and Hex, Binary, Decimal, and Octal representations. Bulk-inspect a list of addresses at once.

Parse any User-Agent string and extract browser, engine, OS, device type, and CPU architecture; auto-detect your own UA; inspect live device information.

Paste any OpenAPI 3.x or Swagger 2.x spec in JSON or YAML; browse endpoints grouped by tag, view parameters, request bodies, and response codes.

Build URLs from scheme, host, port, path, query parameters, and fragment; add/remove query parameters individually; paste an existing URL to parse it back into its components. Bulk-parse a list of URLs at once.

Parse raw email headers and display them in a structured view: routing chain (Received hops with timestamps and delays), authentication results (SPF, DKIM, DMARC pass/fail), DKIM signature details, and a searchable all-headers table.

Upload a .har file captured from browser DevTools; browse all captured requests, filter by URL or status code, and inspect timing.

Paste a Jaeger or OTLP JSON export and visualise the distributed trace as an interactive timeline. Inspect span hierarchies, service breakdown, tags, and timings for any microservice trace.

Query 8 public DNS resolvers simultaneously via DNS-over-HTTPS to check if your DNS records have propagated worldwide. Shows per-resolver answers, TTL, and latency.

Parse standard BIND / RFC 1035 DNS zone files; display SOA, NS, A, AAAA, CNAME, MX, TXT, SRV, CAA, DNSKEY, DS, TLSA records in a structured table. Resolves $ORIGIN and $TTL directives, handles multi-line parentheses, and filters records by type.

Generate a temporary public endpoint via webhook.site and inspect incoming HTTP requests in real time — method, headers, and body.

Connect to an MQTT broker over WebSockets, subscribe to topics, publish messages, and inspect a live message log — all from your browser.

Fetch any RSS 2.0, Atom 1.0, or JSON Feed by URL (via CORS proxy) or paste raw XML/JSON; inspect channel metadata, browse items, and validate required and recommended fields.

Convert images between PNG, JPEG, WebP, and AVIF; resize; batch convert multiple files; edit with brightness/contrast/saturation/blur filters; encode to Base64; view EXIF metadata; ASCII art; compress; aspect ratio calculator.

Optimize SVG files by stripping metadata and compressing paths; format and pretty-print SVG markup; preview the rendered output at any size.

Visual drag-and-drop node editor for SVG <path d=...> attributes. Drag points and control handles; supports M, L, C, Q, Z commands. Outputs the d attribute.

Search 20 000+ icons across PrimeIcons, Heroicons, Bootstrap Icons, Font Awesome Free, Material Design Icons, Simple Icons and Tabler Icons. Copy class names or inline SVG.

Upload any image and generate PNG favicons for all standard sizes (16, 32, 48, 57, 60, 72, 96, 114, 120, 144, 152, 180, 192, 512). Download individually or all at once.

Generate GitHub-style identicon avatars or initials-based avatars from any text — deterministic hash-driven grid pattern or name initials, with color, size, and shape options. Download as PNG or copy as a data URL / SVG.

Preview 27 popular Google Fonts with custom text; compare sizes, toggle bold/italic, and see a size scale — no API key required.

Play, inspect and visualize audio files in-browser. Reads ID3/metadata tags from MP3, FLAC, WAV, OGG, M4A and AAC files — title, artist, album, year, genre, cover art. Renders audio waveforms.

Extract text, view metadata, and render page previews from PDF files — title, author, page count, creation date; merge multiple PDFs, split into single pages, extract a page range, rotate pages, or stamp a watermark. All processing in-browser via PDF.js and pdf-lib.

Create, extract, and inspect ZIP archives entirely in-browser via JSZip — build a ZIP from multiple files with per-file paths and DEFLATE/STORE compression, extract or download individual entries from an existing archive, and inspect a read-only folder-tree summary.

Inspect and extract data from video files entirely in-browser — read duration/dimensions metadata, extract single or evenly-spaced frames as PNG/JPEG, pull out the audio track as WAV, and sample frames into an animated GIF.

Work with JSON i18n locale files: sort keys, find missing keys across languages, merge multiple locales, flatten/unflatten nested keys.

Interactive ASCII character reference showing decimal, hex, octal, and binary values; filter by printable characters, control codes, or extended range.

Convert text to large ASCII art block letters. Choose from block, hash, star, and other fill characters. Supports A-Z, 0-9, and common punctuation.

Create ASCII art diagrams, network topology maps, and text-based flowcharts. Insert pre-built snippets (boxes, arrows, servers, databases), start from common templates, and download as .txt.

Test your camera in-browser: live video feed with resolution and FPS display, multi-camera switching, and snapshot capture with PNG download.

Scan NFC tags with the Web NFC API and inspect their raw records — serial number, record type, and decoded text/URL/MIME/binary data.

Test your browser's built-in text-to-speech and speech-to-text engines. Speak any text with adjustable voice, rate, pitch, and volume, with live word-highlighting as it's spoken; or dictate speech into a live, accumulating transcript with interim and final results across multiple languages.

Record your screen, a window, or a browser tab directly in the browser using the Screen Capture and MediaRecorder APIs, then download the result as a WebM video — no uploads, no plugins, nothing leaves your machine.

Stopwatch with centisecond precision, lap times, countdown timer, Pomodoro mode, and multiple independent timers.

Live, interactive demos of modern browser device and platform APIs — battery, clipboard, permissions, gamepad, device orientation, screen info, network info, storage, notifications, vibration, web share, wake lock, idle detection, and an IndexedDB database browser.

Enter GPS coordinates in decimal degrees or DMS format; visualize the location on an interactive map; parse GPX files with elevation profile chart; geocoder.

Compress text or files with GZip, Deflate (zlib), or raw Deflate; decompress them back — fully client-side using browser CompressionStream APIs.