Parse URLs into components, edit individual parts, and rebuild. Supports encoding/decoding.
Parse and rebuild URLs in seconds
Copy any URL from your browser, API documentation, or code and paste it into the URL input field. The parser automatically breaks it down into all components including protocol, host, path, query parameters, and hash fragments.
Instantly see the URL separated into its constituent parts: protocol (https:), domain (example.com), port (8080), path (/api/users), query parameters (id=123), and hash (#section). Click any component to copy it individually.
Switch to Build mode to edit any URL component independently. Modify the protocol, change the hostname, add or remove query parameters, update the path, or adjust port numbers. Each part can be edited separately without affecting others.
Click Build URL to reconstruct the complete URL from your edited components. The rebuilt URL appears in the input field, ready to copy and use in your code, API tests, or documentation. Use Encode/Decode buttons for URL encoding operations.
Understanding the anatomy of web addresses
A URL (Uniform Resource Locator) is the addressing system used to locate resources on the internet and within networks. URLs are fundamental to web development—every HTTP request, API call, hyperlink, and resource reference uses URL syntax to specify exactly what resource to access and how to access it.
URLs follow a standardized structure defined by RFC 3986 that breaks down into distinct components. Understanding these components is essential for web development, API integration, debugging network requests, and building web applications. Modern web frameworks, REST APIs, single-page applications, and microservices all rely heavily on URL parsing and manipulation.
A complete URL contains up to eight distinct parts, though not all are required for every URL. The standard format is:
protocol://username:password@hostname:port/path?query#fragment
Each component serves a specific purpose in resource identification and retrieval. The protocol specifies how to access the resource (https, http, ftp, ws). The hostname identifies the server (example.com or IP address). The path locates the specific resource on that server (/api/users/123). Query parameters pass data to the server (id=123&sort=name). The fragment identifies a specific section within the resource (#section).
URL parsing is a daily task in modern web development. Frontend developers parse URLs to extract route parameters for client-side routing in React Router, Vue Router, or Next.js. Backend developers parse incoming request URLs to determine which controller and action to invoke, extract resource IDs from paths, and validate query parameter formats.
API integration requires parsing URLs to construct endpoint requests, append query parameters for filtering or pagination, extract authentication tokens from callbacks, and debug malformed URLs in third-party API responses. Single-page applications manipulate URLs without page reloads, updating browser history and deep linking to specific application states.
Deep linking in mobile apps, OAuth redirect URL validation, webhook endpoint parsing, analytics tracking parameter extraction, and SEO canonical URL generation all depend on accurate URL parsing. Understanding URL structure prevents common bugs like double-encoding parameters, incorrect protocol handling, and query parameter parsing errors.
Protocol (Scheme): Specifies the communication protocol—https: for secure web traffic, http: for unencrypted web traffic, ws: or wss: for WebSockets, ftp: for file transfer, mailto: for email links. The protocol determines how the browser or client communicates with the server.
Authentication (User Info): Optional username and password embedded in the URL (username:password@). Deprecated for security reasons—modern applications use Authorization headers instead. Still seen in some legacy systems and internal network resources.
Hostname (Domain): The server's domain name (api.example.com) or IP address (192.168.1.100). Can include subdomains (www, api, cdn) that route to different servers or services. DNS resolves domain names to IP addresses for actual network communication.
Port: TCP port number for the connection. Default ports are implied (80 for HTTP, 443 for HTTPS) and typically omitted. Custom ports (8080, 3000, 5000) must be explicitly specified for development servers or non-standard deployments.
Path: Hierarchical resource identifier on the server (/api/v2/users/123). Resembles file system paths with forward slash separators. REST APIs use path segments to represent resource hierarchy (collections, specific resources, nested resources).
Query String: Key-value parameters after the ? symbol (id=123&filter=active&page=2). Used for filtering, sorting, pagination, search terms, and passing non-hierarchical data. Multiple parameters separated by & symbols. Values must be URL-encoded if they contain special characters.
Fragment (Hash): The portion after # symbol identifying a specific section within the resource (#introduction). Originally used for anchor links to page sections, now heavily used by single-page applications for client-side routing. The fragment is not sent to the server—it's processed entirely by the browser.
A URI (Uniform Resource Identifier) is the broad term for resource identifiers. URLs are a subset of URIs that specify the location and access method for a resource. URNs (Uniform Resource Names) identify resources by name without specifying location, like ISBN numbers for books. In practice, most web developers use "URL" for web addresses and "URI" for abstract resource identifiers in APIs and specifications.
How developers use URL parsing daily
Extract specific query parameters from URLs for analytics tracking, A/B testing, campaign attribution, or feature flags. Parse URLs from user navigation to determine which marketing campaign drove traffic, extract search terms, or read configuration parameters passed via URL.
Build REST API URLs programmatically by combining base URLs with path segments, resource IDs, and query parameters. Validate that constructed URLs have correct protocol, proper encoding, and expected structure before making requests. Debug malformed API URLs that cause 404 or 400 errors.
Parse OAuth callback URLs to extract authorization codes, state parameters, and error messages. Validate that redirect URLs match registered callback URLs exactly, preventing open redirect vulnerabilities. Extract tokens from URL fragments in implicit OAuth flows.
Parse custom URL schemes and universal links for mobile app deep linking. Extract parameters from deep links to navigate users to specific app screens, pre-fill forms, or apply promotional codes. Debug deep link formatting issues that prevent proper app routing.
Master URL parsing, building, and encoding
This URL parser provides instant, client-side URL parsing and building with zero server uploads. All processing happens in your browser using JavaScript's native URL API, ensuring your URLs (which may contain sensitive parameters or tokens) remain completely private.
Paste any URL into the input field to see it automatically parsed into all components. The parser displays protocol, hostname, port (if non-standard), path, query parameters (as individual key-value pairs), hash/fragment, and authentication credentials (username/password if present, though rare in modern URLs).
Every component is displayed separately with click-to-copy functionality. Click the copy button next to any component to copy just that part—perfect for extracting just the hostname, or copying a specific query parameter value without manually selecting text.
Switch to Build mode to edit URL components individually. Modify the protocol (change http: to https:), update the hostname, add or change the port, edit the path, and manage query parameters. Each field is editable independently, letting you experiment with URL variations without manually typing the full URL.
Add query parameters with the "Add Parameter" button, creating new key-value pairs. Edit existing parameter keys or values, or remove parameters you don't need. The query string rebuilds automatically as you add or remove parameters, handling URL encoding and & separators correctly.
Use the Encode button to URL-encode the entire URL, converting special characters to percent-encoded format (%20 for space, %23 for #, etc.). This is useful when you need to pass a URL as a query parameter value to another URL (double-encoded URLs).
The Decode button reverses encoding, converting percent-encoded characters back to readable form. Helpful when debugging encoded URLs from logs or API responses that are hard to read due to encoding.
Invalid URLs trigger a warning indicator showing "Invalid URL format". The parser validates URL structure using the browser's native URL parser—the same validation used by fetch(), XMLHttpRequest, and anchor tag href attributes. Fix syntax errors (missing protocol, malformed hostnames) and the warning clears automatically.
If a URL includes username and password (https://user:pass@example.com), they're displayed in the Authentication section. Passwords are masked with bullet characters for privacy but can still be copied. Note that embedding credentials in URLs is deprecated for security reasons—modern apps use Authorization headers instead.
Everything you need to know about URL parsing
Your URLs never leave your browser
Your URL data never leaves your browser. This parser operates entirely client-side using JavaScript's native URL API built into your web browser. There are no server uploads, no backend processing, and no data transmission to any external services.
This makes the parser safe for sensitive use cases like parsing OAuth redirect URLs containing authorization codes, debugging API endpoints with authentication tokens in query parameters, analyzing webhook URLs with secret parameters, validating deep links with sensitive user data, or any URL parsing that must remain confidential. Use with confidence for production debugging, security testing, or handling regulated data (HIPAA, GDPR, PCI-DSS).
When working with URLs in your applications, avoid embedding sensitive data like passwords, API keys, or tokens in URLs when possible—use HTTP headers instead. Always validate and sanitize user-supplied URLs before redirecting to prevent open redirect vulnerabilities. Use URL parsing (not regex or string manipulation) to validate URL structure reliably. Prefer HTTPS (encrypted) over HTTP for any URLs handling sensitive data.
URL parsing capabilities and specifications
Showing 8 of 94 related tools