Web & Dev

Parse a .env / dotenv file into a JSON object and convert JSON back into .env format, handling quotes, comments, and export prefixes.

Parse and sort Accept-Language or Accept headers by quality value (q-factor).

Appends a deterministic version/hash query param to a list of asset URLs.

Validate common AsyncAPI structure and summarize channels, operations, messages, and servers.

Generate a fetch() snippet with method, headers, bearer token, and JSON body.

Construct Authorization header values for Bearer, Basic, API key, and custom schemes.

Compare Avro record schemas for added, removed, changed, and default-less fields.

Validate common Avro schema structure and summarize records, fields, enums, and unions.

Build an HTTP Basic Authorization header from a username and password.

Generate Block__Element--Modifier CSS class names from block, element and modifier inputs with HTML/CSS preview.

Inspect BIMI TXT records for version, logo URL, authority URL, and deployment checklist.

Compose and explain a Cache-Control header from caching directive checkboxes and durations.

Break down a Cache-Control header and explain each directive and its effect.

Toggle Unix permission bits and get the octal + symbolic chmod value.

Expand an IPv4/IPv6 CIDR block into network, broadcast, mask, and host range.

Validate a CloudEvents JSON event for required attributes and common content-type issues.

Searchable reference of ready-to-copy regex patterns for emails, URLs, IPs, dates, and other common validations.

Build and parse Content-Disposition headers with RFC 5987 filename encoding.

Build a CSP header from per-directive source lists with keyword and nonce/hash helpers.

Parses a CSP header string and flags unsafe or redundant directives.

Searchable reference of common Content-Type media types, charsets, and parameters.

Parse a Cookie or Set-Cookie header into a readable table of attributes.

Generate the Access-Control-* response headers for a desired cross-origin policy.

Translate a cron expression into plain English and list the next several run times, supporting ranges, steps, and lists across all five fields.

Parse a Content-Security-Policy header and flag weak or unsafe directives.

Turn a width:height ratio into aspect-ratio CSS plus a padding-top fallback.

Visually build a border-radius value (including elliptical and per-corner) and copy the CSS.

Visually craft a CSS box-shadow with offset, blur, spread, color, opacity, and inset controls, with a live preview and copyable code.

Design a button (colors, padding, radius, shadow, hover) and copy the CSS.

Compute a responsive clamp() font-size from min/max sizes and viewport range.

Generate polygon, circle, ellipse and inset clip-path values with live preview.

Convert a color between hex, rgb(), hsl(), hwb(), oklch() and named for code.

Design CSS cubic-bezier easing curves with draggable control points and a live animation preview, outputting the transition-timing-function value.

Scan CSS and list all --custom-properties and var() usages with values.

Extract all CSS custom properties (--var declarations) from a stylesheet into a deduplicated, sortable list.

Generate cross-browser custom scrollbar CSS (WebKit pseudo-elements + Firefox).

Combine blur, brightness, contrast and other filters with live image preview.

Set flex container and item properties from dropdowns and copy the generated CSS.

Produce the background-clip text trick CSS for gradient-colored text.

Define grid columns, rows, gaps and named areas, then copy the grid-template CSS.

Create @keyframes with stops plus the animation shorthand, and copy the CSS.

Build responsive @media queries with min/max width breakpoints, orientation, and feature conditions visually.

Build responsive @media queries from breakpoints and feature conditions.

Minify CSS to one line or beautify it with consistent indentation.

Generate CSS columns properties (count, width, gap, rule) with live text preview.

Convert between px, rem, em, vw and vh with configurable root font size and viewport, in both directions.

Score and rank multiple CSS selectors by specificity to spot override order.

Compute the specificity of any CSS selector as an (a,b,c) triple and rank multiple selectors to predict which rule wins.

Build single or stacked text-shadow values with live typographic preview.

Translate common CSS declarations into equivalent Tailwind utility classes, mapping spacing, colors, flex, font, and border properties.

Compose translate, rotate, scale, skew and perspective into one transform value.

Build a transition shorthand from property, duration, timing function and delay.

Create pure-CSS triangles using the border trick for any direction and size.

Convert between px, rem, em, pt, pc, vw/vh and percent using a root and base.

Build a complete curl command from method, URL, headers, body, and auth fields.

Convert a curl command into a browser fetch() call, parsing method, URL, headers, and body into ready-to-paste JavaScript.

Estimate the byte size and overhead of a Base64 data URI for a given raw file size before embedding it.

Decode a data: URI back into its underlying text, revealing the MIME type, encoding, and the original content from base64 or percent-encoding.

Decode DKIM TXT records and extract version, key type, flags, hash list, service, and public key hints.

Build DMARC TXT policies with reporting URIs, alignment, percentage, and subdomain policy.

Parse aggregate DMARC XML reports into source IPs, counts, dispositions, and auth results.

Compare pasted DNS answers from multiple resolvers and flag mismatches.

Build copyable dig commands and summarize pasted DNS records.

Check zone-file records for common SOA, NS, MX, CNAME, TTL, and syntax issues.

Inspect pasted DS, DNSKEY, RRSIG, and NSEC records and outline the trust chain.

Obfuscate an email address (entities / JS) to deter scrapers.

Generate ETag values and matching If-None-Match / If-Modified-Since request headers.

Generate the full set of favicon and app-icon link tags for all platforms.

Summarize GraphQL introspection JSON types, queries, mutations, interfaces, and scalars.

Estimate GraphQL query depth, field count, aliases, fragments, and repeated selections.

Compare GraphQL variable definitions with a variables JSON payload.

Parse .proto text and list packages, services, RPCs, messages, fields, and enums.

Build grpcurl commands with host, service method, headers, TLS, and JSON body.

Build and decode the Strict-Transport-Security header with preload-eligibility checks.

Check Strict-Transport-Security headers against common preload requirements.

Remove selected attributes (style, class, on*, data-*) or whole tags from HTML.

Extract every unique class name and id used in an HTML snippet and output them as a sorted list or CSS stub.

Convert data-* attributes to element.dataset access expressions and back.

Searchable reference of named HTML entities with their character, numeric, and hex codes ready to copy.

Escape text to HTML-safe entities or unescape entities back to characters.

Minify HTML by stripping comments and whitespace, or pretty-print it.

Convert raw HTML into React JSX, renaming class to className, fixing self-closing tags, camelCasing attributes, and converting inline styles to objects.

Strip HTML tags and decode entities to get clean plain text.

Look up any HTTP request or response header to see its purpose, direction, example values, and whether it is standard or deprecated.

Cheatsheet of HTTP methods with safe/idempotent/cacheable/body semantics.

Redact secrets from captured HTTP requests and emit a safer replay snippet.

Look up a status code or symbol to get its class, meaning, and typical use.

Searchable reference of HTTP status codes and their meanings.

Convert an IPv4/IPv6 address between dotted, integer, hex, binary, and expanded forms.

Check whether IP addresses fall within one or more CIDR ranges.

Compute network, broadcast, mask, host range and count from CIDR.

Expand IPv6 addresses to full form or compress to canonical RFC 5952 shorthand.

Flatten a deeply nested JSON object into single-level dot-notation keys, or rebuild nested structure from flattened keys.

Query a JSON document with a dot/bracket path expression (e.g. data.items[0].name) and extract matching values, with wildcard support for arrays.

Compare JSON Schemas for required fields, property changes, and enum narrowing.

Turn a JSON object into a matching HTML form with labeled inputs inferred from each field's value type.

Convert a JSON payload into POJO Java class definitions with typed fields and getters/setters, inferring nested classes and collection generics.

Generate a draft JSON Schema from an example JSON document, inferring types, required keys, array item shapes, and nested object definitions.

Visualize JSON as a collapsible, indented tree with type annotations and node counts, making large nested payloads easy to navigate.

Turn a flat or nested JSON object into a properly encoded URL query string, with bracket notation for nested keys and arrays.

Convert JSON configuration into TOML format and back, handling tables, arrays of tables, nested keys, strings, and numeric/boolean scalars.

Generate schema.org JSON-LD for Article, Product, FAQ, Breadcrumb and more.

Decode and inspect JSON Web Token header & payload (no verification).

Decode a JWT and report human-readable issued/expiry times and remaining validity.

Parse Kafka header key/value pairs and payload metadata for debugging consumers.

Build and parse RFC 8288 Link headers (rel=next/prev, preload, canonical).

Generate placeholder content as ready-to-paste semantic HTML blocks (paragraphs, headings, lists, blockquotes).

Reformat MAC addresses between colon, hyphen, dot (Cisco), and bare notations.

Render Markdown to HTML with a live preview and copyable output.

Map one or many file extensions or filenames to their canonical MIME types and back.

Look up the MIME/content type for a file extension and vice versa.

Test MQTT topic filters with + and # wildcards against sample topics.

Validate MTA-STS TXT and policy file contents for secure inbound mail delivery.

Build multipart/form-data bodies and cURL snippets from field definitions.

Build OAuth 2.0 or OIDC authorization URLs with scopes, PKCE, state, and nonce.

Inspect an OAuth token response, token types, scopes, and expiry.

Parse OpenID Connect discovery metadata and summarize endpoints, algorithms, and grants.

Decode an ID token and check issuer, audience, nonce, expiry, and clock claims.

Parses OG and Twitter meta tags from pasted HTML and shows the resolved share-card fields.

Compare two OpenAPI specs and identify removed paths, methods, parameters, and response codes.

Generate JSON examples from OpenAPI component schemas.

Summarize API keys, HTTP auth, OAuth flows, OpenID Connect URLs, and operation security.

Validate common OpenAPI structure and flag missing info, paths, responses, and schemas.

Build a Permissions-Policy (Feature-Policy) header from per-feature allowlists.

Summarize a Postman collection without importing it into Postman.

Normalize protobuf JSON field names and scalar wrappers for debugging.

Convert between px, rem and em given a configurable root font size.

Convert a URL query string to JSON and back, handling repeated keys.

Edit, add, reorder, dedupe, and sort URL query parameters in an interactive key/value table.

Parse a raw query string into a readable key/value table or pretty JSON, expanding repeated keys and bracket notation into arrays.

Parse a raw HTTP request or response into method, path, status, headers, and body.

Explain Referrer-Policy values and simulate what Referer is sent between two URLs.

Browse a searchable regex syntax reference and snippet library for common patterns like email, URL, IP, and date, with copyable expressions.

Escape arbitrary text into a literal regex pattern or unescape an escaped pattern back to plain text.

Run a regex against each line of pasted text and list which lines match, which do not, and the captured groups.

Convert between numbered capture groups and named capture groups in regex patterns and their backreferences/replacements.

Resolve a relative reference against a base URL to produce the absolute target.

Generate preload, prefetch, preconnect and dns-prefetch link tags.

Builds an <img> srcset and sizes attribute from a base filename and width list.

Generate <img> srcset/sizes (or <picture>) markup from a list of widths.

Compute srcset width descriptors and sizes from a layout and breakpoints.

Test whether a URL path is allowed for a user-agent against pasted robots.txt rules.

Extract subject, issuer, audience, session, and attributes from a SAML assertion.

Map SAML attributes to app claims using a simple mapping table.

Validate NotBefore and NotOnOrAfter timestamps with configurable clock skew.

Build identity provider metadata with SSO endpoints and signing certificate.

Parse SAML entity metadata and list endpoints, certs, bindings, and entity IDs.

Generate a local HTML form for SAML HTTP-POST binding.

Build the URL parameters used by SAML HTTP-Redirect binding.

Decode a SAMLRequest from URL, query string, or form input and inspect the XML.

Decode a SAMLResponse payload and extract assertion, issuer, audience, and subject details.

Inspect XML Signature methods, references, transforms, digests, and embedded certs.

Build service provider metadata for a SAML integration.

Test basic SCIM filter expressions against pasted sample users.

Build a SCIM 2.0 user JSON payload for provisioning tests.

Audit pasted HTTP response headers for CSP, HSTS, frame, MIME, referrer, and permissions policy.

Compare two semantic versions to see which is greater, parse a version into major/minor/patch/prerelease, and test it against a range.

Test whether semantic versions satisfy npm-style version ranges (caret, tilde, comparators, hyphen ranges).

Compute the next semantic version by bumping major, minor, patch, or prerelease according to semver rules.

Parse SSE streams into events, IDs, retry hints, comments, and data payloads.

Build a syntactically correct Set-Cookie header from name, value, and attribute toggles.

Build a Set-Cookie header from name, value and attributes with validation.

Safely quote and escape strings for bash, sh, PowerShell, or cmd.exe.

Generate multiple slug styles (kebab, snake, dot, path, GitHub-anchor) from one input at once for comparison.

Build SOAP 1.1 or 1.2 envelopes from namespace, operation, and body XML.

Parse SOAP 1.1/1.2 faults into code, reason, actor/node, role, and detail.

Inspect SOAP HTTP headers, envelope version, operation, and body payload.

Build SOAPAction and Content-Type headers for SOAP 1.1 or 1.2 requests.

Count SPF mechanisms and estimate DNS lookup pressure before flattening.

Build SPF TXT records from mechanisms, includes, IPv4, IPv6, and all-policy.

Build a data: URI from pasted text with MIME type, charset, and base64 options.

Build SMTP TLS reporting DNS records for mail delivery diagnostics.

Assemble a valid URL from individual scheme, host, port, path, query, and fragment fields.

Break a URL into protocol, host, port, path segments, query parameters, and hash, displayed as a clear labeled component breakdown.

Canonicalize a URL by lowercasing host, resolving dot segments, sorting params, and stripping defaults.

Break a URL into protocol, host, path, query parameters and hash.

Join a base URL with path segments and normalize slashes, dot-segments, and trailing slashes safely.

Canonicalize a URL by sorting and optionally deduplicating query parameters.

Compare the query strings of two URLs and show which params were added, removed, changed, or unchanged.

Parse a User-Agent string into browser, engine, OS and device.

Compose a browser User-Agent string from platform, engine, and version selectors.

Model webhook retry attempts using delay, multiplier, jitter, and max delay.

Parse WSDL XML and list services, ports, bindings, operations, and messages.

Generate a starter SOAP envelope for a selected operation name.

Parse WWW-Authenticate / Authorization challenge headers into scheme and parameters.

Pretty-print and indent minified XML, or minify verbose XML by stripping whitespace between tags, with self-closing tag handling.

Convert an XML document into a structured JSON object, mapping elements, attributes, and text content with a predictable convention.

Generate a documented z-index scale with named layers as CSS variables or a Sass/JS map to avoid stacking chaos.