Developer tools

URL parser and query string viewer

Parse a URL in your browser and see every part of it. Paste an address, and this URL parser splits it into protocol, username, password, host, hostname, port, path, query, fragment and origin. Each query parameter is decoded into an ordered table, repeats included, and the whole result copies or downloads as JSON.

URL to parse

See the parts of an address without visiting it.

Required for relative URLs. Leave blank for absolute URLs. A supplied base must be valid.

Enter a URL, then choose Parse URL.

URLs may contain passwords or tokens. Results and exports include them.

Parsed URL

Your components and query parameters will appear here.

How to parse a URL online

Paste the address into the URL to parse box, or select Example to load a sample with three query parameters. Leave Base URL (optional) empty for a full address that starts with a scheme such as https:. For a relative path such as ../next, enter an absolute base URL there. Then select Parse URL.

The Parsed URL panel shows your Original input above the Normalized URL, with a line that says whether the two differ. Below them are the ten components and a Query parameters table with a number, a Name and a Value for each entry. Copy normalized URL, Copy JSON and Download JSON export the result.

  1. Paste the URL and optional base

    Fill URL to parse or select Example. For a relative path, enter an absolute address in Base URL (optional).

  2. Select Parse URL and inspect

    Compare Original input with Normalized URL, then review the ten components and ordered Query parameters table.

  3. Copy the address or export JSON

    Use Copy normalized URL for the address. Copy JSON and Download JSON include the original input, base, components and query entries.

Editing either field clears the old result until you parse again. Reset empties both fields.

The parts of a URL, field by field

Take https://user:secret@example.com:8080/search?tag=web#results. The protocol is https:, the username is user and the password is secret. The hostname is example.com, the port is 8080, and the host joins them as example.com:8080. The pathname is /search, the search is ?tag=web with its question mark, and the hash is #results.

The origin, https://example.com:8080, is the scheme, host and port together. A field with nothing in it reads (empty). The port stays empty when the address uses the default for its scheme, so https://example.com:443/ reports no port. Components keep their percent-encoded form, so a path with café reads /caf%C3%A9.

Addresses without a host still parse. mailto:someone@example.com?subject=Hi gives the protocol mailto:, the pathname someone@example.com and one query entry, subject, with the value Hi. Its origin is the text null, which marks an opaque origin.

How the query string parser decodes values

The Query parameters table lists every name and value in the order they appear, and its heading shows the count. Repeated names stay on separate rows: ?tag=design&tag=web gives tag twice, once with design and once with web. Nothing is merged or sorted, which matters when a server reads only the first or the last copy.

Decoding follows the browser's URLSearchParams rules and runs once. A plus sign means a space and %2B means a literal plus, so q=1+1 reads 1 1 while r=1%2B1 reads 1+1. A value that was encoded twice decodes one step, so %252F becomes %2F. An invalid escape such as %ZZ stays as typed, and bytes that are not valid UTF-8 become the replacement character.

A bare flag and flag= both show an (empty) value, and the empty pair between && is skipped. The search component keeps the raw text, so you can still see which form the address used.

Why the normalized URL can differ

The Normalized URL is the address as the browser's URL parser rewrites it. HTTPS://Example.COM:443/a/../b becomes https://example.com/b: the scheme and host turn lowercase, the default port 443 goes, and the dot segment resolves. Spaces around the address are trimmed, and tabs and line breaks inside it are removed.

Text outside ASCII is encoded. A path with café becomes /caf%C3%A9, and the domain bücher.example becomes xn--bcher-kva.example, its Punycode form. When anything changes, the line under the two boxes says the normalized URL differs from your input; otherwise it says there were no normalization changes.

Your text is kept as well. The Original input box shows it as you typed it, and the JSON keeps it in originalInput, where a tab shows as \t and a line break as \n. Compare the two to find a stray space, a pasted line break or an uppercase host before the address goes into code or a config file.

Relative URLs and the base field

A relative path needs a base. With the base https://example.com/folder/page, ../next resolves to https://example.com/next. The trailing slash matters: next against https://example.com/folder/ gives https://example.com/folder/next, while against https://example.com/folder it gives https://example.com/next, because folder is then the last path segment.

A path that starts with two slashes takes only the scheme from the base, so //other.example/path becomes https://other.example/path. Without a base, a relative path such as /path?x=1 fails, and the message asks you to check the address or supply an absolute base URL.

A base must itself be a full absolute URL whenever the field is not empty, even when the address you parse is already absolute; a base of /relative is rejected. An absolute address ignores a valid base. After a parse with a base, the panel also shows the Original base and the Normalized base, and the JSON records both.

What the JSON export holds

Copy JSON and Download JSON give the same UTF-8 text, and the download is named parsed-url.json. The object holds originalInput and originalBase as you typed them, normalizedBase (null when there is no base), normalizedUrl, and changed, which is true when the normalized URL differs from your input.

Then come components, with the ten fields named above, and queryEntries, an array of name and value pairs. An array keeps duplicate names and their order, which an object keyed by name would lose. The line under the Parsed URL heading gives the number of query entries and the JSON size, such as 3 query entries · 749 B JSON for the Example address.

The export includes any username, password or token in the address, so treat the file like the URL itself. If the browser blocks the clipboard, the page selects the text for you to copy by hand, and for Copy JSON it opens View JSON / manual copy first.

Limits

The tool reads syntax only. It never opens the address, follows redirects, looks up DNS or checks a site's reputation, so a successful parse says nothing about whether a link works. Addresses that start with mailto:, data: or javascript: parse as inert text.

Each parse reads one URL. The browser removes line breaks inside the box, so two addresses on two lines join into one: https://a.example/x and https://b.example/y become a single URL on a.example whose path is /xhttps://b.example/y. Parse them one at a time.

There is no fixed length or time limit. Browser memory decides what completes, and Cancel, shown while a parse runs, stops it. A long query table fills in batches of 100 rows, so the page keeps responding while it draws.

The tool does not percent-encode or decode a string on its own. It decodes query names and values while parsing a URL.

Questions

What is a URL parser?

A URL parser reads a web address and splits it into named parts: scheme, credentials, host, port, path, query and fragment. This one uses the URL parser built into your browser, the standard one browsers apply to links, and then decodes the query into name and value pairs you can read, copy or export.

How do I find the parameters in a URL?

The query is everything after the question mark and before any #. Paste the URL and select Parse URL: the Query parameters table lists each name and decoded value in order, with a count in its heading. The search field shows the raw query text, and No query entries appears when there is none.

Can it show the full URL behind a short link?

No. The tool reads only the text you paste and never requests the address, so it cannot follow a redirect. A short link such as https://bit.ly/abc123 parses into its own host, bit.ly, and its path, /abc123. Finding where it leads takes a request to the short-link service, which this page never makes.

Does a successful parse mean the link is safe?

No. A parse only shows that the browser accepts the syntax. The tool performs no reputation, destination, DNS or security check, and a javascript: or data: address parses like any other text. Read the hostname field yourself; a host such as xn--bcher-kva.example is the Punycode form of a domain written in other letters.