URL Parser
Break any URL into protocol, host, path, query parameters and fragment for easy inspection.
A URL looks like a single string but is really six or seven named parts stacked together: scheme, host, port, path, query and fragment. When a link misbehaves, the fastest way to understand why is to take it apart. This parser splits any URL into its components and lists every query parameter it carries.
Paste a URL and the tool shows the protocol, hostname, port, host, path, query string and fragment as separate labeled rows. Query parameters are extracted into their own table with each key and value on its own line, so a cluttered query string becomes a readable list. The normalized URL is shown as well, matching what a browser would resolve it to.
Parsing happens locally in your browser using the platform's own URL implementation, so the results match exactly what your browser and JavaScript runtime would see. Nothing is uploaded, and the URL you inspect never leaves your machine - useful when the link contains a signed token or a private id.
Features
- Break a URL into protocol, hostname, port, host, path, query, fragment and origin.
- Extract every query parameter into a readable key-value table.
- Preserve parameter order and duplicates exactly as they appear.
- Show the normalized URL after the parser has applied its rules.
- Clear error message when the input is not a valid absolute URL.
- Runs entirely offline - the URL is never transmitted.
How to Use
- 1
Paste a URL
Enter a complete URL including the scheme - https://example.com/path?q=1, not just example.com.
- 2
Parse
Press Parse URL. Each component is shown on its own labeled row.
- 3
Read the parameters
Scroll to the query-parameters table for every key and value, in order, including duplicates.
- 4
Copy the result
Copy the normalized URL when you need the canonical form, for example for an integration test.
Example
Parse a tracked link
https://example.com/products?id=42&utm_source=newsletter&lang=en#reviews↓
protocol: https · host: example.com · path: /products · params: id=42, utm_source=newsletter, lang=en · fragment: reviewsPort and query values
http://localhost:8080/api?token=abc123&token=def456↓
protocol: http · hostname: localhost · port: 8080 · params: token=abc123, token=def456Common Problems
Omitting the scheme
Without https:// or http://, a string like example.com is a relative reference, not an absolute URL. The parser rejects it with a hint rather than guessing the scheme for you.
Misreading reserved characters
A value containing an ampersand or a space must be percent-encoded first. If a parameter seems to split into two, the original value was never encoded - check it with the URL encoder.
Assuming parameter order does not matter
Order can matter to some APIs, and duplicates are meaningful in several cases (filters, repeated keys). The parser preserves both exactly as they appear.
Reading a URL that was never normalized
Browsers apply default ports, empty paths and other rules. The normalized output shows what the URL resolves to, which can differ from the string you typed.
Trusting a query string as a security boundary
Values in a URL are visible in logs and referrer headers. If the URL carries sensitive data, that data is exposed wherever the link travels.
Reading percent-encoded values raw
A query value like q=What%20is%20this is encoded. The parser decodes values, so the table shows "What is this" - but the raw query-string row still shows the encoded form. Match the two when debugging a mismatch.
Technical Details
The parser uses the WHATWG URL standard implemented by browsers. That means protocol, hostname, port, host, pathname, search and hash are split with the exact same rules a browser applies when it follows a link.
Query parameters are extracted with URLSearchParams, which decodes percent-encoded values and preserves both the order and the occurrence of duplicate keys.
The host component combines hostname and port; origin combines scheme, hostname and port. The normalized href reflects any corrections the parser applies, such as filling in an empty path.
Parsing is local and requires no network access. A URL can be parsed even when it points at a server that does not exist, because the tool never contacts it.
Parsing follows the same rules a browser uses, including the quirks: an empty path becomes "/", a missing port is omitted, and the fragment is dropped from the value of the search. The normalized href row reflects all of those adjustments.
Query parameters are listed in document order with duplicates kept, which matches what server-side frameworks report and avoids the common pitfall of an object that silently collapses repeated keys.
Frequently Asked Questions
Why must I include https://?
The parser follows the URL standard, which only treats strings with a scheme as absolute URLs. Without a scheme the string is a relative reference, which has no well-defined host or port.
What does "origin" mean?
The origin is the scheme plus the host, including the port when present. It is what browsers use to decide whether two pages belong to the same security context.
Can it parse a URL with a space in it?
A raw space makes a string invalid as a URL. The parser reports it as invalid - encode the space as %20 first, then it parses cleanly.
Is my URL sent anywhere?
No. Parsing happens entirely in your browser. The URL never leaves your machine and is not logged or stored.
Why are there two rows with the same parameter name?
The URL genuinely contains that parameter twice. Query strings allow duplicates, and some APIs read all of them. The table lists each occurrence in order instead of collapsing them.
What is the fragment and why is it not sent to the server?
The part after # tells the browser which section of the page to scroll to. It is a client-side instruction, so requests to the server exclude it - which is why it appears in the parse but never in logs.
Can I parse a relative URL like /about?
No, and the tool says so. A relative reference has no scheme or host to split. Resolve it against a base URL first, then parse the absolute result.
What does it mean when two URLs normalize to the same href?
They point at the same resource. Defaults such as port 443 on https are filled in, so https://a.com and https://a.com:443 normalize identically - a common source of "duplicate" links in analytics.
Data & Privacy
Your data stays in your browser. Nothing is uploaded.
- Processing
- Local
- Upload
- None
- Server Storage
- None
- Account
- Not required
Related Tools
Base64 Encode & Decode
Convert text to Base64 or decode it back, with an optional URL-safe mode - all in your browser.
Encoding & Conversion
URL Encoder / Decoder
Percent-encode text for safe use in URLs and query strings, or decode it back to readable form.
Encoding & Conversion
HTML Entity Encoder / Decoder
Convert HTML to its escaped entity form or decode entities back to readable markup.
Encoding & Conversion
Unicode Converter
Escape text as \uXXXX sequences or decode them back to readable characters, for JSON, JavaScript and Java.
Encoding & Conversion
Hex Converter
Convert text to hex bytes and back, revealing the UTF-8 representation of any string.
Encoding & Conversion
Binary Converter
Convert text to its 8-bit binary form and decode binary strings back to readable text.
Encoding & Conversion