URL Component Parser

Parse any URL or URI locally in your browser into scheme, auth, host, TLD, port, path segments, query parameters, and hash with live RFC 3986 editing.

No uploadsNo sign-upInstant results
RFC 3986 / WHATWG URL InspectorLive Host · Path · Query · Hash Editor100% Local • Zero Uploads
Parse & Edit URL
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free URL Component Parser?

Built from the ground up for strict privacy, instant execution, and zero friction. No subscriptions, paywalls, or account registrations required.

WHATWG & RFC 3986 Component Breakdown

Decomposes scheme, userinfo credentials, origin, hostname, subdomain, registrable domain, TLD, explicit or default port, indexed path segments, query pairs, and hash fragment.

Live Bidirectional URL Reconstruction

Edit individual fields—such as switching hostnames, changing ports, updating path segments, or modifying query values—and reassemble a normalized URL immediately.

IDN, IPv6 & Custom URI Scheme Support

Handles Punycode internationalized domains (xn--), bracketed IPv6 literals ([::1]:8080), non-HTTP deep-link schemes (myapp://), and port-explicit internal endpoints.

100% Client-Side Zero-Leak Inspection

Runs entirely in browser memory so OAuth redirect URLs, AWS S3 presigned links, webhook tokens, and basic-auth credentials are never transmitted to any server.

Utiliome vs Traditional Cloud Alternatives

Compare our local-first WebAssembly engine against legacy cloud tools.

Feature Utiliome (Local Browser) Legacy Cloud Converters
RFC 3986 & WHATWG URL Decomposition Extracts protocol, username, password, hostname, port, pathname, search & hash Naive regex splitting that fails on IPv6 hosts, ports, or auth credentials
Interactive Query Parameter Table Decodes all ?key=value pairs into an editable table and reconstructs the URL live Displays the raw query string as a single unparsed text blob
IDN Punycode & Percent-Encoding Inspection Shows both raw percent-encoded segments and decoded Unicode / Punycode (xn--) hosts Hides percent-encoding differences that cause canonical URL mismatches
Zero URL Telemetry 100% client-side parsing — internal staging URLs and OAuth callbacks never leave tab Logs parsed URLs on remote servers or triggers link-preview crawlers
How it works

How to Use URL Component Parser in 3 Easy Steps

No software installation required. Everything runs directly inside your web browser.

1

Paste or Upload a URL

Enter an HTTP(S) address, custom URI scheme, IPv6 service endpoint, or signed callback link into the input field, or drop a plain-text file.

2

Inspect Decomposed URI Fields

Review the parsed origin, authority credentials, subdomain/domain/TLD split, decoded path segment list, query key-value parameters, and fragment identifier.

3

Edit Components and Copy Output

Modify any component independently—swap staging hosts, adjust port numbers, or update parameters—and copy the rebuilt URL or structured JSON breakdown.

How URL Component Parsing and Live Reconstruction Work

Quick Answer: A URL parser tokenizes a uniform resource identifier along RFC 3986 structural delimiters (://, @, :, /, ?, #), isolating authority, hierarchical path segments, query parameters, and fragment state so each field can be inspected or mutated without manual string slicing.

Manual regular expressions and naive split('/') helpers frequently break when confronted with basic-auth credentials, explicit ports, percent-encoded slashes (%2F), multi-part public suffixes like .co.uk, or question marks embedded inside hash fragments. A specification-aware parser scans delimiters in strict syntactic order before decoding individual components.

Consider a complex webhook delivery URL containing credentials, a multi-level subdomain, a non-default TLS port, an encoded path segment, query parameters, and a fragment anchor:

https://deploy:tok_9f8a@staging.api.example.co.uk:8443/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log

Decomposing this URI yields discrete, independently editable properties:

{
  "href": "https://deploy:tok_9f8a@staging.api.example.co.uk:8443/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log",
  "protocol": "https:",
  "scheme": "https",
  "username": "deploy",
  "password": "tok_9f8a",
  "origin": "https://staging.api.example.co.uk:8443",
  "host": "staging.api.example.co.uk:8443",
  "hostname": "staging.api.example.co.uk",
  "subdomain": "staging.api",
  "domain": "example.co.uk",
  "tld": "co.uk",
  "port": "8443",
  "pathname": "/v2/orgs/acme%20corp/webhooks",
  "pathSegments": ["v2", "orgs", "acme corp", "webhooks"],
  "search": "?event=push&active=true",
  "queryParams": {
    "event": "push",
    "active": "true"
  },
  "hash": "#delivery-log"
}

Mutating Components Without Corrupting Escapes

When debugging across environments, you often need to point a captured production or staging callback URL at a local service while preserving exact path encoding and signed query payloads. Changing scheme to http, hostname to localhost, port to 3000, and clearing username/password cleanly reconstructs:

http://localhost:3000/v2/orgs/acme%20corp/webhooks?event=push&active=true#delivery-log

Notice that the third path segment (acme corp) automatically retains its %20 percent-encoding inside pathname, preventing whitespace truncation in HTTP request lines or Markdown logs.

RFC 3986 Generic URI Syntax vs the WHATWG URL Standard

Quick Answer: RFC 3986 defines stateless ABNF grammar rules for generic URIs, whereas modern browsers, Node.js, Deno, and Cloudflare Workers implement the WHATWG URL Living Standard, which enforces special-scheme normalization, default port elision, backslash conversion, and UTS #46 Punycode IDNA encoding.

Understanding subtle divergences between RFC 3986 and the WHATWG URL Standard prevents routing bugs, broken signature verification, and Server-Side Request Forgery (SSRF) vulnerabilities.

Canonical Structural Grammar (RFC 3986 Section 3)

RFC 3986 divides every generic URI into five primary components in fixed left-to-right precedence:

  foo://user:pass@example.com:8042/over/there?name=ferret#nose
  \_/   \_______________________/ \_________/ \_________/ \__/
   |                |                  |           |        |
scheme          authority             path       query   fragment
  • Scheme: Must begin with an ASCII letter followed by letters, digits, +, -, or . (ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )). Normalized to lowercase.
  • Authority: Preceded by // and terminated by the next /, ?, #, or end-of-string. Subdivides into optional userinfo@, host (registered name, IPv4 address, or bracketed [IPv6] literal), and optional :port.
  • Path: Hierarchical sequence of / segments. Dot-segments (. and ..) are resolved via the remove_dot_segments algorithm (RFC 3986 Section 5.2.4).
  • Query: Introduced by the first ? after the path and terminated by # or end-of-string.
  • Fragment: Introduced by # and consumes every remaining character to the end of the URI, including any subsequent ? or / characters.

WHATWG Special Schemes vs Opaque Paths

The WHATWG URL state machine designates six schemes as special: http, https, ws, wss, ftp, and file. Special URLs undergo strict normalization that non-special schemes (mailto:, urn:, data:, myapp://) skip:

  1. Default Port Elision: https://example.com:443/api serializes as https://example.com/api with port set to "" because 443 matches the default port for https (80 for http/ws, 443 for https/wss, 21 for ftp). Custom schemes like redis://cache.internal:6379 retain :6379.
  2. Backslash Normalization: In special schemes, reverse solidus characters (\) inside authority and path segments normalize to forward slashes (/), whereas non-special schemes treat \ as an opaque path character.
  3. Empty Path Slash: https://example.com serializes with a trailing root slash (pathname = "/"), whereas custom://host may carry an empty pathname.
  4. IDNA Punycode Conversion: Unicode domain labels such as https://münchen.example/path are converted via UTS #46 to ASCII Compatible Encoding (https://xn--mnchen-3ya.example/path) in the hostname property.

IPv6 Literals and Multi-Label Public Suffixes

IPv6 addresses contain colons that would collide with the :port delimiter unless enclosed in square brackets per RFC 2732, as in http://[2001:db8:85a3::8a2e:370:7334]:8080/health. Furthermore, decomposing a hostname into subdomain, registrable domain, and TLD cannot rely on splitting at the last dot: country-code second-level domains (example.co.uk, app.com.au) and platform suffixes require multi-label suffix awareness so co.uk is recognized as the effective TLD rather than uk.

Security Note: Parser Differentials and SSRF

Security allowlists fail when a proxy validates a URL using a permissive RFC 3986 regex while the upstream HTTP client fetches it using a WHATWG parser. Inputs containing multiple @ delimiters (https://allowed.example@169.254.169.254/latest/meta-data/) or backslashes (https://attacker.example\@allowed.example/) can cause one parser to read allowed.example as the host while the HTTP client connects to 169.254.169.254 or attacker.example. Always validate origin and hostname after parsing with the exact WHATWG normalization your HTTP client uses, and strip or reject unexpected username/password authority fields.

URL Component Parser vs Query String Parser vs URL Encoder: Which Tool Do You Need?

Quick Answer: Use URL Component Parser to inspect and rebuild full URI structure across scheme, authority, host, port, path, query, and hash. Use Query String Parser for deep nested query editing and bidirectional JSON conversion, or URL Encoder & Decoder to escape raw character strings.

URL manipulation tasks fall into distinct syntactic layers. Choosing the tool built for the exact layer you are working on avoids double-encoding delimiters or losing nested parameter types.

Feature URL Component Parser (This Tool) Query String Parser URL Encoder & Decoder Percent Encoder
Primary Input Complete URL or custom URI ?a=1&b=2, form body, or JSON Raw string or encoded URL component Raw text requiring strict RFC 3986 %XX escaping
Authority, Host, Port & TLD Split Full breakdown + live editing Strips non-query URL parts No structural parsing No structural parsing
Path Segment Inspection Indexed decoded path array Not applicable No structural parsing No structural parsing
Nested Query Arrays & Brackets Flat key-value query inspection Full tag[]=a, filter[k]=v & JSON sync Not applicable Not applicable
Space Encoding Control (+ vs %20) Standard URI component rules Configurable + or %20 serialization Supports component & form escaping Strict RFC 3986 %20 byte encoding

When to Switch to a Sibling Tool

  • Editing deeply nested API filters or converting query parameters to JSON: Open the Query String Parser when working with repeated array keys (?id=1&id=2), qs-style bracket notation (filter[status]=open), application/x-www-form-urlencoded POST payloads, or JSON test fixtures.
  • Escaping or unescaping an isolated parameter value: Use the URL Encoder & Decoder when you have a raw string containing &, =, +, or Unicode characters that must be safely escaped via encodeURIComponent semantics before insertion.
  • Strict RFC 3986 byte-level escaping for OAuth / AWS SigV4: Use the Percent Encoder when signing canonical requests where characters like !, ', (, ), and * must be hex-encoded.
  • Generating clean SEO path segments from titles: Use URL Slugify to transliterate human headings into lowercase hyphenated path slugs.
FAQ

URL Component Parser FAQ and Technical Guide

Everything you need to know about using Utiliome's free online url parser.

What is the difference between host, hostname, and origin in a parsed URL?

In the WHATWG URL specification, hostname contains only the domain name or bracketed IPv6 literal (api.example.com or [::1]). host appends :port solely when a non-default explicit port is present (api.example.com:8443, or api.example.com if using port 443 over https). origin prepends the scheme and :// delimiter to host (https://api.example.com:8443), representing the Web security boundary used by CORS and postMessage.

Why does a query string after a hash (#) stay inside the fragment instead of queryParams?

Under RFC 3986 Section 3.5, the first # delimiter terminates the path or query component and begins the fragment identifier, which extends to the very end of the URI. In hash-routed single-page application links such as https://app.example.com/#/orders?status=paid, ?status=paid is part of the client-side hash (#/orders?status=paid) and is never sent to the HTTP server. To parse parameters embedded inside a hash route, copy the substring starting at ? into the Query String Parser.

Why do default ports like :80 and :443 disappear when rebuilding an HTTP or HTTPS URL?

Special schemes in the WHATWG URL Standard define default ports (80 for http and ws, 443 for https and wss, 21 for ftp). When a URL explicitly specifies its scheme's default port—such as https://example.com:443/v1—compliant normalizers omit :443 during canonical serialization so equivalent origins compare identically. Non-default ports like :8443 or :3000 are always preserved.

How are percent-encoded slashes (%2F) inside path segments handled?

Structural / delimiters are split before percent-decoding occurs. In /repos/acme%2Fcore/commits, splitting first produces three segments (["repos", "acme%2Fcore", "commits"]), and segment-level decoding then yields acme/core as a single identifier. Decoding %2F prior to path splitting would erroneously create four path segments and break REST route matching.

Is it safe to inspect OAuth callback URLs or AWS S3 presigned URLs here?

Yes. All URL parsing, component editing, and JSON serialization execute 100% locally inside your browser's JavaScript runtime. No network requests, analytics beacons, or server-side logs ever touch your pasted URLs, X-Amz-Signature parameters, code grants, or userinfo credentials.