Does it use the WHATWG URL spec?

Yes — the same URL parser browsers use (via the URL constructor). What the tool shows is exactly what your browser sees when it makes a request to that URL.

What about URL fragments (#anchor)?

Captured in the hash field. Fragments aren't sent to the server — they're client-side only — but they're often used to encode SPA routing state, which the tool can decode further.

Can it handle very long URLs?

Yes — query strings with hundreds of parameters parse instantly. Long URLs (multi-KB) work too but become hard to scan visually.

url · whatwg · rfc 3986 · live

Break a URL into its components

Q: Is anything sent to a server?

No — the URL is parsed locally. Tokens or PII in tracking params stay local.

Inspect protocol, host, port, path, query, fragment, and user-info. Runs entirely in your browser using the WHATWG URL parser.

URL Parser

Length

83 B

83 chars

Status

parsed

live

Protocol

https

scheme

Params

query keys

input · url

output · components

protocolhttps

originhttps://api.example.com:8080

usernameuser

password****

hostnameapi.example.com

port8080

pathname/v1/users/42

search?fields=id,name&sort=desc

hash#profile

params (2)

fields           = id,name
sort             = desc

Quick Start

How to inspect a URL

The WHATWG URL parser breaks a URL into the same components your browser uses.

01
Paste a URL
Anything starting with http, https, ws, or another scheme.
Lookups reference the IANA registries (MIME, HTTP status, TLDs) bundled at build time — no live network calls, no rate limits, no leaked queries.
inputIANAregistryofflinelive
input · queryurl · IANA
```
https://api.example.com/v1/x
```
loaded · IANA bundlespec · ready
02
Read the components
Origin, hostname, port, path, query string, and fragment are split out.
Builders emit canonical syntax per the relevant RFC (9110 for HTTP, 5322 for headers, 3986 for URLs) so the output passes spec-compliant parsers.
fieldsRFC 9110canonicalspec-compliantlive
fields · options9 · live
```
origin → https://api.example.com
pathname → /v1/x
```
options applied · livecanonical
03
Inspect query params
Each ?key=value pair is decoded and listed.
Validation flags common pitfalls — uppercase header names, smart quotes inside Content-Type, missing ;charset=utf-8 — before they bite production.
paramsvalidationlintpitfallslive
query · looked updecoded · ready
```
fields = id,name
sort = desc
```
result · livevalidated
04
Copy or download
Grab the structured summary or the raw URL.
Copy writes the snippet directly into your clipboard; downloads emit the right extension and MIME so curl/httpie pick them up correctly.
exportclipboardMIME-correctblobcurl-ready
ok · copiedready · done
```
Copied summary
```
shipped · ready to shipsuccess

Pro tips

Web-spec details that bite later

Idempotency saves retries

POST/PUT/DELETE should be safely retried. Use idempotency keys and return the same response on duplicate requests.

Match RFC 9110 status codes

Don’t invent codes. 422 for validation errors, 409 for conflicts, 429 for rate limits. Standard codes work with off-the-shelf clients.

Set <code>Cache-Control</code> deliberately

Default browser caching is conservative. Use max-age + stale-while-revalidate for hot endpoints.

Validate Open Graph in dev

OG tags break silently. Use a previewer like OG Generator + Facebook’s debugger before launch.

CORS is a server concern

The browser sends the preflight; the server decides. Wildcard origins disable credentials — be explicit.

MIME drives behaviour

Servers must send the right Content-Type. Browsers sniff but the spec says they shouldn’t — be explicit to avoid surprises.

Use Cases

When to parse a URL

Routing, validation, debugging.

Routing debug

Inspect the exact path and query the server saw. Bundled from IANA registries at build time — no live network call, no rate limit, no leaked queries. The MIME, TLD, and status-code tables are baked in so the tool works offline once loaded.

spec-compliant

Auth handoff

Extract user-info / hash params from OAuth callbacks. Output is canonical per the relevant RFC (9110 for HTTP, 5322 for headers, 3986 for URLs), so spec-compliant parsers accept it as-is. Cross-browser and cross-library behaviour stays consistent.

offline

URL normalisation

Spot trailing slashes, default ports, and case quirks. Pairs with the curl-to-fetch converter for end-to-end test stubs — copy the curl from DevTools, paste, get an idiomatic fetch() body. Drop into Playwright/Vitest fixtures without manual translation.

IANA-backed

Webhook payloads

Pull a hostname or path out of a logged URL. Catches common pitfalls (uppercase header names, smart quotes inside Content-Type, missing ;charset=utf-8) before they bite production. Validation flags rather than auto-corrects so you stay in control.

RFC-aligned

Tracking params

List every UTM key on a campaign URL. Validation runs as you type — copy only when the output is shaped correctly. The output drops directly into nginx, Apache, or CDN configs without re-formatting or re-quoting.

production-grade

Cross-origin checks

See the exact origin compared in CORS rules. Same input plus same options always produces identical canonical output, so the tool is safe to embed in CI scripts that diff against expected configs.

curl-ready

FAQ

Frequently asked questions

Which parser does this use?

The browser's built-in URL constructor, which implements the WHATWG URL standard (a superset of RFC 3986 with sane defaults).

Why is the port empty?

If the URL uses the default port for its scheme (80 for http, 443 for https), the URL object normalises it to an empty string.

What about user:password URLs?

Browsers parse them but won't send credentials. They're shown here so you can audit logs that contain them.

How do you handle repeated query keys?

Each key/value pair is listed in order. URLSearchParams preserves duplicates.

Is anything sent to a server?

No — parsing runs locally in your browser.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!