Self-Hosted URL Parsing Libraries: Ada vs uriparser vs llhttp vs rust-url

Introduction

Every web application, API client, and HTTP server needs to parse URLs. Whether you are extracting query parameters, validating user input, or routing requests, a fast and standards-compliant URL parser is essential infrastructure. While it is tempting to roll your own regex-based parser, the URL specification (WHATWG URL Standard and RFC 3986) has enough edge cases to fill a book — percent-encoding, IPv6 literals, Unicode normalization, and relative resolution are just the beginning.

This article compares four production-grade URL parsing libraries across C++, C, Rust, and Node.js ecosystems: Ada (WHATWG-compliant, C++), uriparser (RFC 3986, C), llhttp (Node.js’s HTTP parser), and rust-url (Rust’s reference implementation).

Comparison Table: URL Parsing Libraries at a Glance

Deep Dive: URL Parsing Libraries

Ada URL — WHATWG-First Modern C++

Ada URL is the fastest WHATWG-compliant URL parser available, developed as part of the Internet Archive’s modernization efforts. Unlike older parsers that target only RFC 3986, Ada implements the full WHATWG URL Standard, which is what browsers and modern web platforms use.

1
2
3
4
5

# Clone and build Ada
git clone https://github.com/ada-url/ada.git
cd ada
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build

A basic Ada usage example in C++:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include "ada.h"
#include <iostream>

int main() {
    auto url = ada::parse("https://example.com/path?query=value#fragment");
    if (url) {
        std::cout << "Protocol: " << url->get_protocol() << "
";
        std::cout << "Host: " << url->get_host() << "
";
        std::cout << "Path: " << url->get_pathname() << "
";
        std::cout << "Search: " << url->get_search() << "
";
    }
    return 0;
}

Ada’s Node.js bindings demonstrate its performance advantage — benchmarks show Ada parsing URLs 2-4 times faster than Node.js’s built-in legacy url.parse().

uriparser — The RFC 3986 Workhorse

uriparser is a strictly RFC 3986-compliant URI parsing library written in C. It has been the go-to choice for embedded systems and C applications since 2006, providing a mature and battle-tested API with zero external dependencies.

1
2

# Install uriparser on Debian/Ubuntu
sudo apt-get install liburiparser-dev

Usage in C:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <uriparser/Uri.h>
#include <stdio.h>

int main() {
    UriUriA uri;
    const char* errorPos;
    if (uriParseSingleUriA(&uri, "https://example.com/path", &errorPos) == URI_SUCCESS) {
        printf("Scheme: %.*s
", (int)uri.scheme.afterLast - (int)uri.scheme.first, uri.scheme.first);
        printf("Host: %.*s
", (int)uri.hostText.afterLast - (int)uri.hostText.first, uri.hostText.first);
        uriFreeUriMembersA(&uri);
    }
    return 0;
}

uriparser excels in environments where the WHATWG standard’s complexity is unnecessary — embedded devices, IoT gateways, and simple HTTP clients. Its focus on RFC 3986 means predictable, well-understood behavior without the complexity of browser-style URL normalization.

llhttp — Node.js’s Streaming HTTP Parser

llhttp is the HTTP/1.1 parser that powers Node.js (since v12), replacing the older http_parser. Unlike Ada and uriparser which parse complete URLs, llhttp is a streaming parser designed for high-throughput HTTP server applications. It processes incoming data byte-by-byte using a state machine compiled from a TypeScript DSL.

1
2
3
4
5

# Build llhttp from source
git clone https://github.com/nodejs/llhttp.git
cd llhttp
npm install
npm run build

The compiled C output is a single pair of .c/.h files that can be embedded in any project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include "llhttp.h"

int on_url(llhttp_t* parser, const char* at, size_t length) {
    printf("URL fragment: %.*s
", (int)length, at);
    return 0;
}

int main() {
    llhttp_t parser;
    llhttp_settings_t settings;
    llhttp_settings_init(&settings);
    settings.on_url = on_url;

    llhttp_init(&parser, HTTP_REQUEST, &settings);
    const char* request = "GET /api/v1/users?page=2 HTTP/1.1
Host: example.com

";
    llhttp_execute(&parser, request, strlen(request));
    return 0;
}

The key advantage of llhttp is its streaming design — it never buffers the entire request, making it ideal for high-concurrency servers that must parse millions of URLs per second with minimal memory overhead.

rust-url — Rust’s Safe URL Parsing

rust-url is the reference implementation of the WHATWG URL Standard in Rust, used by the Servo browser engine and virtually every Rust web framework (Actix, Rocket, Axum). It provides memory safety guarantees through Rust’s ownership model while maintaining competitive performance.

1
2

[dependencies]
url = "2"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

use url::Url;

fn main() -> Result<(), url::ParseError> {
    let url = Url::parse("https://example.com/search?q=rust+url+parsing#results")?;
    println!("Scheme: {}", url.scheme());
    println!("Host: {:?}", url.host());
    println!("Path: {}", url.path());
    println!("Query: {:?}", url.query());
    println!("Fragment: {:?}", url.fragment());
    Ok(())
}

rust-url handles all the tricky edge cases that naive parsers miss: IPv6 address parsing (https://[::1]:8080/), IDN punycode conversion, and percent-encoding normalization.

Choosing the Right URL Parser for Your Project

Your choice depends on your language ecosystem and requirements:

• C++ with WHATWG compliance → Ada URL. It is the fastest option with full modern URL standard support.
• C with embedded/RFC-only needs → uriparser. Minimal dependencies, mature, and battle-tested since 2006.
• Node.js HTTP servers → llhttp. Already integrated into Node.js core; the streaming design excels at high throughput.
• Rust projects → rust-url. The de facto standard, deeply integrated into the Rust web ecosystem with excellent safety guarantees.

For related infrastructure, see our self-hosted load balancer comparison and our TLS termination proxy guide.

Security Considerations

URL parsing is a common attack vector. The 2017 http_parser vulnerability (CVE-2017-11163) allowed denial-of-service through specially crafted URLs. Modern parsers have addressed many of these issues:

• Ada uses C++17 idioms and fuzz-testing via OSS-Fuzz
• llhttp improved on http_parser by generating safe C from a TypeScript DSL, eliminating hand-written pointer arithmetic
• rust-url eliminates memory safety bugs at compile time through Rust’s ownership system
• uriparser has been hardened over 15+ years of production use

Always validate and sanitize URL inputs at your application boundary, regardless of which parser you choose.

Deploying URL Parsers in Web Applications

When integrating URL parsing into a self-hosted web service, consider the parsing location in your request pipeline. For reverse proxy setups, URL parsing typically happens at the application layer after the proxy forwards the request:

1
2
3
4
5
6

# Nginx passes the full URL to your application
location /api/ {
    proxy_pass http://localhost:8080;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Original-URL $scheme://$host$request_uri;
}

For high-throughput API gateways processing millions of requests per day, the parser’s throughput directly impacts tail latency. Ada and llhttp both support zero-copy parsing from raw buffers, avoiding allocation overhead. When deploying behind a load balancer, ensure your parser reconstructs the original URL from X-Forwarded-Proto and Host headers rather than parsing the internal proxy URL. This is a common source of subtle bugs where redirects and link generation use internal hostnames instead of the public-facing domain.

FAQ

What is the difference between the WHATWG URL Standard and RFC 3986?

The WHATWG URL Standard is the living specification used by web browsers. It defines how URLs are parsed, serialized, and resolved in the context of web pages. RFC 3986 is the older IETF standard that defines the generic URI syntax. WHATWG handles edge cases like backslash-to-slash conversion and default port stripping that RFC 3986 leaves undefined. For web applications, prefer WHATWG-compliant parsers. For general-purpose URI handling in non-browser contexts, RFC 3986 is sufficient.

Can I use these libraries in embedded systems?

Yes. uriparser is specifically designed for resource-constrained environments with zero external dependencies. Ada compiles to a compact binary (under 200KB) and supports cross-compilation for ARM and RISC-V targets. llhttp compiles to a single C file that can be linked into any embedded HTTP server.

Which parser is fastest for high-throughput servers?

llhttp’s streaming architecture makes it ideal for high-concurrency HTTP servers. It processes data as it arrives without buffering, minimizing memory pressure. Ada is faster for single-URL parsing benchmarks but requires the complete URL string upfront. For Node.js servers, llhttp is already the default and is optimized for real-world HTTP traffic patterns.

How do I handle percent-encoding correctly?

Each library provides encoding/decoding utilities. Ada and rust-url follow the WHATWG percent-encoding algorithm, which encodes all characters except the “URL code points” (alphanumerics plus -._~). uriparser provides uriUnescapeInPlaceA() for RFC 3986 percent-decoding. Always decode AFTER parsing, not before — this avoids double-decoding vulnerabilities.

Are there WebAssembly builds available?

Ada URL provides an official npm package (ada-url) with WebAssembly fallback for browsers. The package auto-detects native bindings and falls back to WASM when native compilation is unavailable. rust-url can be compiled to WebAssembly through wasm-pack for browser-based URL validation.

💰 Want to test your market judgment? I use Polymarket for prediction market trading — the world’s largest prediction market platform, where you can bet on anything from election results to technology regulation timelines. Unlike gambling, this is a real information market: the more you know, the higher your win rate. I’ve made solid returns predicting technology-related events. Register with my referral link: Polymarket.com