URL Parser

Parse any URL into its components: protocol, domain, path, query parameters and fragment. No signup. Ideal for developers debugging links, APIs and web addresses.

Remove Ads
Remove Ads

Result

Remove Ads

Share on Social Media:

A URL parser splits a web address into its parts — protocol, hostname, port, path, hash, origin and query parameters — free, with no account. Paste the URL, click Parse, and read each part in a labelled table, with the query string broken into one decoded key = value pair per line. It runs entirely in your browser, so the URL is never uploaded. The URL must include its protocol (https://…); a bare domain is rejected.

On this page

  1. How to Parse a URL Step by Step
  2. What the Parts of a URL Are
  3. Parsing Versus Reading a URL by Eye
  4. Who Needs a URL Parser
  5. Pro Tips for Working With URLs
  6. Common URL Parsing Mistakes to Avoid
  7. Related Tools You May Need Next
  8. Frequently Asked Questions

How to Parse a URL Step by Step

  1. Paste your URL. Drop the URL into the input box, including its protocol — https:// or http://. It can be a simple web address or a complex one with many query parameters and a fragment.
  2. Click Parse. Pasting alone does nothing — the result appears only after you click the Parse button (or press Enter in the input). A bare domain with no protocol shows an Invalid URL — include the protocol, e.g. https:// message instead.
  3. Read the components. Each part appears in its own labelled row: Protocol, Hostname, Port, Path, Hash, Origin and Query parameters. A missing port reads (default) and a missing hash reads (none).
  4. Examine the query parameters. The query string is broken into individual parameters and their values, one key = value pair per line, so you can see exactly what data the URL carries — which is often the most useful part.
  5. Use the parsed parts. Apply the separated components to debugging, understanding, or building a URL, working with the exact pieces rather than the whole string.

Illustration of a URL split into its parts — protocol, hostname, path, query and fragment — with a card for each part

What the Parts of a URL Are

A URL, or web address, has a well defined structure made of distinct parts, each with a specific role. The parser shows seven of them, using the browser's own URL rules, so the breakdown always follows the standard structure. The protocol specifies how to access the resource, the hostname identifies the server, the port is the network port (or (default) when the URL uses the scheme's usual port), the path locates the resource on that server, the hash points to a section within the resource, the origin is the scheme plus hostname plus port, and the query string passes data.

The query string is often the most interesting part to parse, because it carries data as a series of parameters. It begins with a question mark and consists of name and value pairs separated by ampersands. These parameters pass information to the server or page, such as search terms, filters, tracking codes or settings. Breaking the query string into its individual parameters reveals exactly what data a URL is carrying, which is frequently what a developer needs to see.

One detail worth knowing: the path and the query values are treated differently. The path row keeps its percent-encoding — /a%20b is shown as /a%20b — while query parameter values are decoded, so q=hello%20world reads as q = hello world and x=%26 reads as x = &. Do not read the path row as decoded text.

Row shownWhat it isExample from the worked URL
ProtocolHow to access the resourcehttps
HostnameThe server, including any subdomainexample.com
PortThe network port, or (default)8080
PathWhere the resource sits on the server/path/page
HashThe section within the resource, or (none)#section
OriginScheme + hostname + porthttps://example.com:8080
Query parametersDecoded key = value pairs, one per linea = 1, b = 2

Worked example: https://example.com:8080/path/page?a=1&b=2#section gives Protocol https, Hostname example.com, Port 8080, Path /path/page, Hash #section, Origin https://example.com:8080, and Query parameters a = 1 and b = 2. A second example, https://www.example.com/search?q=hello%20world&lang=en, shows Port (default), Hash (none), Origin https://www.example.com, and the decoded query value q = hello world.

Parsing Versus Reading a URL by Eye

ComponentRoleExample position
ProtocolHow to access the resourceAt the start, before the hostname
HostnameIdentifies the serverAfter the protocol
PathLocates the resourceAfter the hostname
QueryPasses data as parametersAfter a question mark
FragmentPoints to a sectionAfter a hash

Parsing a URL by eye is difficult for complex addresses, which is where a parser helps. A URL with a long path and many query parameters becomes a dense, hard to read string where it is easy to misread where one part ends and another begins, or to miss a parameter. A parser separates every component cleanly and lists the query parameters individually, turning an opaque string into a clear, structured breakdown you can read at a glance.

URL parsing is a common need in web development and debugging. When a link is not working, an API call is misbehaving, or you need to understand what data a URL carries, breaking it into its parts is the first step. Analysing the query parameters reveals what is being passed, checking the path confirms the resource, and examining the protocol and hostname verifies where the request goes. This structured view makes diagnosing URL related problems far easier.

Who Needs a URL Parser

Web developers debugging links. A developer breaks down a URL to check its parts when a link is not working, verifying the protocol, hostname, path and parameters are as expected.

People working with APIs. Someone analysing an API request URL parses it to examine the query parameters being sent, confirming the request carries the right data.

Marketers checking tracking parameters. A marketer parses a URL to inspect its tracking and campaign parameters, confirming that links carry the correct tracking data.

People analysing query strings. Someone who needs to see exactly what parameters a URL is passing parses it to read each parameter and value individually and clearly.

Anyone understanding a URL. A person faced with a long, complex URL parses it to understand its structure and what it does, turning an opaque string into clear parts.

Laptop showing a URL split into its protocol, hostname, path, query and fragment parts

Pro Tips for Working With URLs

Focus on the query parameters. The query string usually carries the most interesting information. Parsing it into individual parameters and values reveals what data the URL passes, which is often the key to understanding or debugging it.

Check the protocol for security. The protocol at the start indicates how the resource is accessed, including whether the connection is secure. Checking it confirms the URL uses a secure protocol where that matters.

Decode encoded parameter values. Query parameter values are often URL encoded, with special characters replaced by codes. The parser already decodes the values it shows, but to decode a value yourself, our URL Encode Decode tool converts encoded values back to their original characters.

Verify tracking parameters. For marketing links, parsing reveals the tracking and campaign parameters. Checking these confirms your links carry the correct tracking data before you use or share them.

Build URLs by understanding the parts. Knowing the components helps you construct correct URLs. Our UTM Builder adds tracking parameters correctly, using the query string structure the parser reveals.

Watch for the fragment. The fragment, after a hash, points to a section within the page and is handled by the browser, not sent to the server. Noting it helps you understand behaviour that depends on the page section.

Remember the path stays encoded. The Path row shows percent-encoding as written, while query values are decoded. If a path looks scrambled, that is the encoding, not an error — decode it separately if you need the plain text.

Common URL Parsing Mistakes to Avoid

Misreading a complex URL by eye. Long URLs with many parameters are dense and easy to misread, causing you to misjudge where parts begin and end or to miss a parameter. Parsing separates every component cleanly, avoiding the errors of reading a complex URL by eye.

Pasting a bare domain. The tool rejects anything without a protocol, so example.com gives the Invalid URL — include the protocol, e.g. https:// message twice, with no browser message. Always include https:// or http:// at the start.

Ignoring URL encoded values. Query parameter values are often encoded, so special characters appear as codes rather than their real form. The parser decodes the values it shows, but the Path row is not decoded — reading it without decoding can mislead you about the actual value.

Overlooking the query parameters. The query string carries the data a URL passes, which is often the most important part for debugging. Focusing only on the hostname and path and overlooking the parameters misses what the URL is actually doing.

Confusing the fragment with a parameter. The fragment after a hash is not a query parameter and is not sent to the server; it points to a section within the page. Treating it as a parameter, or expecting the server to receive it, misunderstands how the URL works.

Expecting credentials to appear. A URL carrying a username and password, such as https://user:[email protected]/…, is parsed, but the credentials appear in no row of the table — the tool silently leaves them out, so do not use it to check them.

Expecting a result without clicking. Pasting the URL does nothing on its own — the table appears only after you click Parse.

Entering nothing, or only spaces, in the input box. An empty box shows the browser's "Please fill out this field." message and one "Invalid Input" message; an input of only spaces shows the "Invalid Input" message twice, with no browser message. Either way, the previous result stays unchanged.

Related Tools You May Need Next

URL Encode Decode. To decode encoded parameter values, or encode them, convert between the two forms.

UTM Builder. To build tracking URLs correctly, add parameters in the right structure.

URL Opener. Open a list of URLs at once.

3D illustration of a URL split into its parts with a cube for each component

Frequently Asked Questions

How do I parse a URL?

Paste the URL into the input box, including its protocol, and click Parse. The tool breaks it into its standard components: Protocol, Hostname, Port, Path, Hash, Origin and Query parameters, each shown in its own labelled row. The query string is broken into individual parameters and their values. This gives you a clear, structured breakdown of the URL, far easier to read than a long, dense address, which is invaluable for debugging links, analysing API requests, and understanding what a URL carries.

What parts of a URL does the parser show?

Seven rows: Protocol (for example https), Hostname (for example example.com, including any subdomain), Port (for example 8080, or (default)), Path (for example /path/page), Hash (for example #section, or (none)), Origin (for example https://example.com:8080), and Query parameters as one decoded key = value pair per line. There is no separate subdomain row and no username or password row.

What is the query string in a URL?

The query string is the part of a URL that carries data, beginning with a question mark and consisting of parameters as name and value pairs separated by ampersands. These parameters pass information such as search terms, filters, settings or tracking codes to the server or page. It is often the most interesting part to parse, since breaking it into its individual parameters reveals exactly what data the URL is carrying, which is frequently what a developer needs to examine.

Why is a bare domain rejected?

Because the parser uses the browser's built-in URL rules, which require a scheme. A bare domain such as example.com has no protocol, so the parser cannot tell how the resource should be accessed, and it shows Invalid URL — include the protocol, e.g. https://. Add https:// (or http://) at the start and it parses.

Does the parser decode percent-encoded values?

For query parameters, yes. The values shown come decoded, so q=hello%20world reads as q = hello world and x=%26 reads as x = &. The Path row is different: it keeps its percent-encoding, so /a%20b is shown as /a%20b. To decode a path or any other encoded value yourself, use the URL Encode Decode tool.

Does it show a username and password in the URL?

No. A URL carrying credentials, such as https://user:[email protected]/…, is parsed, but the username and password appear in no row of the result table — the tool silently leaves them out. Do not use this parser to check credentials in a URL, and avoid sharing URLs that contain them.

What is the Origin row?

The origin is the scheme plus the hostname plus the port — for example, https://example.com:8080 for a URL on port 8080, or https://www.example.com when the default port is used. It identifies the site the URL belongs to, which is the same origin browsers use when deciding what a page is allowed to access.

Why is parsing a URL useful for debugging?

Because when a link is not working, an API call is misbehaving, or you need to understand what a URL does, breaking it into its parts is the first diagnostic step. Analysing the query parameters shows what data is being passed, checking the path confirms the resource being requested, and examining the protocol and hostname verifies where the request goes. This structured view turns an opaque string into clear components, making URL related problems much easier to diagnose.

What is the fragment part of a URL?

The fragment is the part of a URL after a hash symbol, and it points to a specific section within the resource, such as a particular heading on a page. Importantly, the fragment is handled by the browser and is not sent to the server, unlike the query string. This means it affects where the browser scrolls or what section is shown, but the server does not receive it. Noting the fragment helps you understand page behaviour that depends on sections.

Can I use a URL parser for tracking links?

Yes, it is very useful for tracking links. Marketing URLs carry tracking and campaign parameters in the query string, and parsing the URL breaks these out so you can inspect each one and confirm the link carries the correct tracking data. This lets you verify that campaign links are set up properly before using or sharing them, catching any missing or incorrect tracking parameters that would otherwise undermine your ability to measure the link's performance.

Is the URL parser free?

Yes, it is completely free with no account and no signup. You can parse as many URLs as you like, as often as you like, at no cost. It runs entirely in your browser on any device, so the URLs you analyse are processed locally and there is nothing to download or install — paste a URL, click Parse, and read the structured breakdown of components and query parameters.