Paste a URL and see every part of it: protocol, host, port, path, query parameters, fragment and origin. The parsing is done by the browser's own URL implementation, the one that follows the standard it uses when actually making a request — so what you see is what a request would really do, including the cases a regular expression fumbles, such as credentials in the authority or an IPv6 literal host next to a port. Query parameters are listed decoded, because that is what the receiving application gets: a value written as hello%20world shows as a space. Repeated keys stay as separate rows rather than being collapsed, since which one a server honours varies. A password in the URL is masked rather than printed. Nothing is fetched — the URL is taken apart, never requested.
| Part | In https://[email protected]:8080/a?b=1#top |
|---|---|
| Protocol | https |
| Username | user |
| Host | x.com |
| Port | 8080 |
| Path | /a |
| Query | b=1 |
| Fragment | top |
| Origin | https://x.com:8080 |
No. It is parsed only. Nothing is requested, so you can safely inspect a URL you do not want to visit — which is often exactly why you are looking at it.
Because that is what the receiving application actually receives. Showing hello%20world rather than 'hello world' would hide the answer most people come here for. The raw query string is still listed as its own component.
Because it implements the same standard the browser uses to make requests, so the breakdown matches reality. Regular expressions go wrong on credentials in the authority, bracketed IPv6 hosts with ports, and encoded characters inside the path.
It has no scheme — something like /path/to/page or example.com/page. A relative reference has no host of its own until it is resolved against a base, and inventing one would show you a host that was never in your input. Add https:// and try again.
Because they genuinely appear twice, and which one a server uses is up to that server — some take the first, some the last, some build a list. Collapsing them would hide a real cause of confusing behaviour.
Parsing is done with the browser's own URL implementation rather than a regular expression, which matters because that implementation follows the WHATWG standard the browser itself uses when making a request — so the breakdown shown here is what would actually happen, not an approximation. Regular expressions get the awkward cases wrong in ways that are hard to notice: credentials embedded in the authority, an IPv6 literal host wrapped in brackets alongside a port, a path containing an encoded question mark, a scheme-relative reference. The standard parser handles all of those, and also normalises in the ways a browser does, which is often the thing you are trying to see. Query parameters are listed decoded, so a value written as hello%20world appears as a space and %26 as an ampersand — that is what the receiving application will actually get, and showing the raw form would obscure the answer people come here for. Repeated keys are preserved as separate rows rather than collapsed, since a query string may legitimately carry the same name several times and which ones survive is server-dependent. A password present in the authority is masked rather than printed: it will have come from a URL somebody pasted, quite possibly into a shared screen, and echoing it serves no purpose the rest of the breakdown does not. A relative URL is reported as such with the reason, rather than being silently rejected or guessed at with an invented base, because guessing would produce a host that was never in the input. Nothing is fetched — the URL is only taken apart, never requested.