URL parser

Parse a URL into its parts instantly

Paste a URL and get protocol, username, password, hostname, port, path, and params — all in your browser

Last updated: January 29, 2026

CreatorFrank Zhao

Your url to parse:

Protocol

Username

Password

Hostname

Port

Path

Params

Introduction / overview

The URL Parser takes a URL string and splits it into the parts you normally care about: protocol, username/password, hostname, port, path, and the raw query string.

Practical idea: when an API request fails, the bug is often in a tiny URL detail (a missing slash, a wrong port, an extra query key, or an unescaped character).

Who is this for?

Developers debugging redirects, proxies, and request signing.
QA testers verifying deep links and campaign URLs.
Security reviewers checking for credential leaks in URLs.

If you need to percent-encode or decode query values, pair this with our Encode/decode URL-formatted strings tool.

How to use / quick start

Paste the URL

Put the full URL in the input box. Include the protocol when possible (for example $\texttt{https:}$ ).

Read the extracted fields

The tool shows key parts like hostname and pathname. Copy any field with the copy buttons.

Check query parameters

Below “Params”, you get the query key/value pairs. This is the fastest way to spot a missing parameter or a typo.

How to interpret results

If $\texttt{port}$ is empty, the URL is using the default port for the protocol.
$\texttt{search}$ includes the leading $\texttt{?}$ .
If you see $\texttt{username}$ and $\texttt{password}$ , treat it as sensitive.

Worked example (step-by-step)

Input:https://me:[email protected]:3000/url-parser?key1=value&key2=value2#the-hash

\text{protocol}

=

\texttt{https:}

,

\text{hostname}

=

\texttt{calculatorvast.com}

\text{username}

=

\texttt{me}

,

\text{password}

=

\texttt{pwd}

,

\text{port}

=

\texttt{3000}

\text{pathname}

=

\texttt{/url-parser}

,

\text{search}

=

\texttt{?key1=value\&key2=value2}

Interpretation: now you can quickly confirm the endpoint $\texttt{calculatorvast.com:3000}$ and verify your query keys $\texttt{key1}$ and $\texttt{key2}$ .

Real-world examples / use cases

Debugging a broken redirect

Background: a link works locally but fails in staging.
Input:https://staging.example.com:8443/callback?code=abc123&state=xyz
Result: check $\texttt{port=8443}$ and verify the query keys $\texttt{code}$ and $\texttt{state}$ exist.

Spotting credentials in URLs

Background: you’re reviewing logs and want to ensure secrets are not embedded in links.
Input:https://user:[email protected]/api/v1/data
Result: the parser exposes $\texttt{username}$ and $\texttt{password}$ immediately.

Verifying API base URL + path

Background: your client builds URLs dynamically.
Input:https://api.example.com/v2/users/42
Result: confirm $\texttt{hostname=api.example.com}$ and $\texttt{pathname=/v2/users/42}$ .

Checking query encoding

Background: a query value contains spaces or special characters.
Input:https://example.com/search?q=hello%20world&lang=en
Result: use the parser to confirm the query keys, then use URL encoder/decoder to encode new values safely.

Common scenarios / when to use

Client-side URL building

Useful when template strings produce double slashes or missing segments in $\texttt{pathname}$ .

Deep links with fragments

Great for validating links that rely on $\texttt{#fragment}$ navigation.

Auth callbacks

Confirm the presence (and spelling) of keys like $\texttt{code}$ and $\texttt{state}$ .

Privacy checks

Catch unexpected credentials or tokens in URLs before sharing screenshots or logs.

Query-heavy dashboards

Useful when analytics tools add many query keys and you need to isolate the important ones.

Reverse proxy configs

Verify whether the upstream should include $\texttt{port}$ and the exact $\texttt{pathname}$ .

When this may not apply: if you’re parsing non-standard strings (custom schemes, partial URLs, or legacy formats), you may need domain-specific parsing rules.

Tips & best practices

Fast sanity checks

Always confirm $\texttt{hostname}$ first; it’s the most common “looks right” bug.
If a request reaches the wrong service, check $\texttt{port}$ and the first path segment.
For query debugging, copy the full $\texttt{search}$ string and paste into a diff tool.

Avoid common mistakes

Don’t share URLs that include $\texttt{username:password@}$ .
Don’t manually “fix” spaces—use a proper encoder (see URL encoder/decoder).
Duplicate query keys exist in the real world; this tool keeps the last value per key.

Calculation method / formula explanation

This tool follows the standard URL structure used by modern browsers. Think of a URL as a template that can include optional pieces.

\texttt{URL = scheme://[username:password@]host[:port]/path?query#fragment}

Square brackets mean “optional”.

In the browser, parsing is effectively: $\texttt{parts = new\ URL(input)}$ . If parsing fails, the tool marks the URL as invalid.

\text{protocol}

=

\texttt{https:}

,

\text{pathname}

=

\texttt{/api/v1/items}

,

\text{search}

=

\texttt{?q=abc}

Variables / fields (what they mean):

$\texttt{protocol}$ : scheme + colon, for example $\texttt{https:}$ .
$\texttt{hostname}$ : domain or IP.
$\texttt{pathname}$ : the path portion, starting with $\texttt{/}$ .
$\texttt{search}$ : the raw query string, including the leading $\texttt{?}$ .

Related concepts / background info

Absolute vs relative URLs

This parser expects a fully-qualified URL. A string like $\texttt{/docs?page=2}$ is “relative” and may need a base URL before parsing.

Query strings

The query string begins with $\texttt{?}$ and uses $\texttt{&}$ to separate key/value pairs.

Security note

Credentials in URLs can leak through browser history, logs, referrers, and analytics. Prefer headers or secure token storage.

Frequently asked questions (FAQs)

Why does the protocol include a colon?

Browsers represent it as $\texttt{https:}$ (including the colon) to match the URL specification.

Why is the port empty?

If you don’t explicitly specify a port, the URL uses the default (for example, $443$ for $\texttt{https:}$ ).

Can a URL have duplicate query keys?

Yes. This tool displays query parameters as key/value pairs, and keeps the last value per key when building the list.

Why can’t I parse a relative URL like /path?x=1?

Relative URLs need a base to become absolute. Convert to an absolute URL first (for example,https://example.com/path?x=1).

How do I encode a query value safely?

Use a proper encoder to avoid breaking the query string. Try our URL encoder/decoder tool.

Does this tool send my URL to a server?

No. Parsing happens locally in your browser.

Limitations / disclaimers

This tool is for inspection and debugging. It should not be treated as a security scanner, and it does not validate whether a hostname is reachable or safe.

External references / sources

Next step

If you’re fixing encoding issues, jump to URL encoder/decoder. If you’re comparing URLs, copy the parts you care about and paste them into a diff tool.

Related Calculators

Chronometer

Use a simple chronometer (stopwatch) to track elapsed time down to milliseconds. Runs locally in your browser.

Try Now

Email normalizer

Normalize email addresses to a standard format for easier comparison. Useful for deduplication and data cleaning. Runs locally in your browser.

Try Now

ETA calculator

Estimate the time needed to consume a total amount at a constant rate, and get an expected end time. Runs locally in your browser.

Try Now

JWT parser

Parse and decode your JSON Web Token (JWT) and display its content. All computation runs locally in your browser.

Try Now

MIME types

Know which file extensions are associated to a MIME type, and which MIME type is associated to a file extension. Includes a full MIME types table.

Try Now

Lorem ipsum generator

Generate random Lorem Ipsum placeholder text with customizable paragraphs, sentences, and word counts. Runs locally in your browser.

Try Now