Online URL Parser & Parameter Extractor
Instantly parse any URL online. Extract scheme, hostname, path, query parameters, and fragments directly in your browser with 100% client-side privacy.
- Duplicate Query Parameters found: tag.
Color-Coded URL Anatomy (RFC 3986)
Visual breakdown of URL segments
Query Parameter Extractor & Editor
5 parameters extracted
| Parameter Key | Raw Value | Decoded Value | Length | Actions |
|---|---|---|---|---|
| tech | 4 | |||
| asc | 3 | |||
| 2 | 1 | |||
| javascript | 10 | |||
| python | 6 |
Overview
The ToolMono URL Parser & Parameter Extractor is a browser-based web address inspector designed for frontend engineers, backend developers, digital marketers, SEO specialists, and security analysts. Whether you are debugging REST API query strings, inspecting marketing UTM campaign parameters, testing OAuth 2.0 redirect URIs, or dissecting web addresses, ToolMono decomposes Uniform Resource Locators (URL) into their exact anatomical parts.
Unlike server-side parsing tools that send your web requests over HTTP networks, ToolMono executes 100% client-side URL parsing using the browser's native WHATWG URL API. Your private links, internal staging environments, API tokens, and credentials never leave your local device. For complementary developer workflows, explore our URL Encoder & Decoder, JSON Formatter, JWT Decoder, and Hash Generator.
How to Parse URLs Online
Paste your full web address (e.g., https://user:pass@sub.example.com:8080/path?q=search#hash) into the main input box or click Load Sample URL.
ToolMono instantly extracts Scheme, Host, Subdomain, Domain, TLD, Port, Path, Query Parameters, Hash, and UTM campaign tags with visualizer cards.
Edit parameters live using the Query Parameter Editor or Interactive URL Builder, then click Copy Params as JSON, Copy Breakdown JSON, or Export CSV.
URL Components at a Glance
| Component | Example | Required? | Description |
|---|---|---|---|
| Protocol / Scheme | "https" | Yes | Specification protocol used to transfer resource. |
| Userinfo / Credentials | "user:pass" | Optional | Basic authentication credentials embedded in Authority. |
| Hostname | "app.example.com" | Yes | Full domain name or IP address of the target server. |
| Subdomain | "app" | Optional | Third-level domain prefix preceding registrable domain. |
| Domain & TLD | "example.com" (.com) | Yes | Registered domain name and Top-Level Domain suffix. |
| Port | "8080" / "443" | Optional | TCP/UDP port number (defaults to 443 for HTTPS, 80 for HTTP). |
| Pathname | "/v1/users" | Optional | Hierarchical directory and file path on server. |
| Query String | "?id=100&sort=asc" | Optional | Non-hierarchical key-value parameter pairs. |
| Fragment / Hash | "#profile" | Optional | Client-side document anchor identifier. |
Anatomy of a URL: Key Components Explained
A URL (Uniform Resource Locator) is a formatted string that specifies where a resource is located on a computer network and how to retrieve it. Standard URL syntax follows this anatomical order:
scheme://[user:password@]host[:port]/path[?query][#fragment]
Defines the access protocol (e.g. https, http, ftp, mailto).
Domain name or IP address and optional network port number.
Resource location path on the host server (directory + filename).
Key-value search parameters and page anchor fragment.
URL Query Parameter & Search String Parsing
How Query Strings Work
Query parameters begin with a question mark (?) and separate key-value pairs with ampersands (&). ToolMono automatically decodes percent-encoded characters (e.g. %20 to spaces, %2F to slashes) for easy reading while preserving raw values for copy and JSON exports.
URLs such as ?tag=javascript&tag=python are preserved as arrays when copied or exported as JSON: { tag: ["javascript", "python"] }.
Parameters without explicit values like ?flag&debug=true are parsed as empty strings (flag: "") without dropping the key.
UTM Marketing Campaign Parameter Analysis
When marketing tracking parameters are present in your URL, ToolMono automatically displays a dedicated UTM Campaign Inspector highlighting standard Urchin Tracking Module tags:
- utm_source: Identifies advertiser or site (e.g. google, newsletter).
- utm_medium: Identifies marketing channel (e.g. cpc, email, social).
- utm_campaign: Identifies specific product promotion or campaign.
- utm_content: Differentiates ads or links pointing to same destination.
How to Parse URLs Programmatically
1. JavaScript (Browser WHATWG URL & URLSearchParams)
// JavaScript (Browser & Node.js 18+) - Native WHATWG URL API
const rawUrl = "https://user:pass@sub.example.com:8080/path/to/page.html?q=search&sort=asc#section";
const url = new URL(rawUrl);
console.log("Protocol:", url.protocol); // "https:"
console.log("Hostname:", url.hostname); // "sub.example.com"
console.log("Port:", url.port); // "8080"
console.log("Pathname:", url.pathname); // "/path/to/page.html"
console.log("Search:", url.search); // "?q=search&sort=asc"
console.log("Hash:", url.hash); // "#section"
// Iterating Query Parameters using URLSearchParams
const params = url.searchParams;
params.forEach((value, key) => {
console.log(`Param ${key}: ${value}`);
});2. Node.js (url Module)
// Node.js - Native 'url' Module
const { URL, URLSearchParams } = require('url');
const myUrl = new URL('https://example.com/api/v1/users?page=2&limit=50#users-list');
console.log('Host:', myUrl.host); // "example.com"
console.log('Pathname:', myUrl.pathname); // "/api/v1/users"
console.log('Query Page:', myUrl.searchParams.get('page')); // "2"3. Python 3 (urllib.parse)
# Python 3 - Native 'urllib.parse' Module
from urllib.parse import urlparse, parse_qs
raw_url = "https://example.com/shop?utm_source=google&utm_medium=cpc#reviews"
parsed = urlparse(raw_url)
print("Scheme:", parsed.scheme) # "https"
print("Netloc:", parsed.netloc) # "example.com"
print("Path:", parsed.path) # "/shop"
print("Query:", parsed.query) # "utm_source=google&utm_medium=cpc"
# Parse query string parameters into dict
params = parse_qs(parsed.query)
print("UTM Source:", params.get('utm_source')[0]) # "google"4. PHP (parse_url)
// PHP 8+ - Native parse_url() & parse_str()
$url = "https://example.com/products/item.php?category=tech&id=42#desc";
$parts = parse_url($url);
print_r($parts);
// Parse query string into array
parse_str($parts['query'], $queryParams);
echo "Category: " . $queryParams['category']; // "tech"5. Go (net/url)
// Go - Native 'net/url' Package
package main
import (
"fmt"
"net/url"
)
func main() {
rawURL := "https://example.com:8080/search?q=golang&lang=en#results"
u, err := url.Parse(rawURL)
if err != nil {
panic(err)
}
fmt.Println("Scheme:", u.Scheme)
fmt.Println("Host:", u.Host)
fmt.Println("Path:", u.Path)
queryParams := u.Query()
fmt.Println("Query 'q':", queryParams.Get("q"))
}6. Java (java.net.URI)
// Java 17+ - Native java.net.URI Class
import java.net.URI;
public class UrlParserExample {
public static void main(String[] args) throws Exception {
URI uri = new URI("https://example.com:8080/api/data?q=java#top");
System.out.println("Scheme: " + uri.getScheme());
System.out.println("Host: " + uri.getHost());
System.out.println("Port: " + uri.getPort());
System.out.println("Path: " + uri.getPath());
System.out.println("Query: " + uri.getQuery());
}
}7. C# (.NET System.Uri)
// C# .NET Core - System.Uri Class
using System;
class Program {
static void Main() {
var uri = new Uri("https://example.com:8080/products/details?id=101#specs");
Console.WriteLine($"Scheme: {uri.Scheme}");
Console.WriteLine($"Host: {uri.Host}");
Console.WriteLine($"Port: {uri.Port}");
Console.WriteLine($"AbsolutePath: {uri.AbsolutePath}");
Console.WriteLine($"Query: {uri.Query}");
}
}8. Ruby (URI.parse)
# Ruby - Native 'uri' Library
require 'uri'
uri = URI.parse("https://example.com/blog/article?author=jane#comments")
puts "Scheme: #{uri.scheme}"
puts "Host: #{uri.host}"
puts "Path: #{uri.path}"
puts "Query: #{uri.query}"URL Parsing Standards (WHATWG & RFC 3986)
Modern web browsers follow the WHATWG URL Standard, which defines how real-world web addresses are parsed, normalized, and encoded. RFC 3986 provides the generic theoretical URI syntax framework.
| Feature | RFC 3986 (IETF) | WHATWG URL Standard |
|---|---|---|
| Scope | Generic URI Syntax specification | Living standard used by web browsers and Node.js |
| Unicode / IDN | Requires manual percent encoding | Native support for Internationalized Domains (Punycode) |
| Default Ports | Treats `:80` as explicit port | Automatically strips default ports (80/443) |
Security & Privacy Rules
Security Commitment: Zero Server Uploads
Many online tools send entered web links across third-party networks. ToolMono operates under a strict Client-Side Privacy rule:
- Native Browser WHATWG URL API
- No Remote Server Uploads
- No Query Parameter Logging
- 100% Offline Capable
Frequently Asked Questions
References & Standards
RFC 3986: Uniform Resource Identifier (URI) Generic Syntax
Official IETF standard defining scheme, authority, path, query, and fragment.
WHATWG URL Living Standard Specification
Modern web standard for URL parsing and serialization used by modern web browsers.
MDN Web Docs: URL API Documentation
Official Mozilla guide to the browser URL interface.
Related Tools
Browse all toolsURL Encoder & Decoder
Free, 100% client-side URL encoder and decoder. Convert text and query parameters into RFC 3986 percent-encoded strings or decode URLs with smart double-encoding detection and structural URL analysis.
JSON Formatter
Free online JSON formatter, beautifier, and validator. Format, indent, minify, and inspect JSON with real-time syntax error detection in your browser. 100% client-side.
Regex Tester
Test JavaScript regular expressions with live match highlighting, capture-group inspection, flags, and replacement preview. 100% client-side privacy.
Base64 Encoder Decoder
Free, 100% client-side Base64 encoder and decoder. Convert text, strings, and data to Base64 or Base64URL instantly with UTF-8 support, padding controls, and client-side processing.
JWT Decoder Online
Decode JWT tokens instantly in your browser. Inspect headers, payload claims, verify signatures, convert timestamps, and debug JWTs securely with 100% client-side processing.
Hash Generator
Generate hashes and file checksums locally in your browser. Compare digests, copy results, and use MD5, SHA-1, SHA-2, SHA-3, BLAKE2, and supported HMAC algorithms.