---
id: pyfaup-rs
version: "0.4.16"
license: GPL-3.0
license_treatment: copyleft
maintenance: active
---

# pyfaup-rs — Python bindings for faup-rs Rust library

License: copyleft · Maintenance: active · Downloads: 92.5K/mo

## What it is and what it does

pyfaup-rs is a Python URL parser built in Rust using PyO3, designed to extract and normalize URL components efficiently. It parses a URL string into scheme, credentials, host, subdomain, domain, TLD, port, path, query, and fragment, exposing them as attributes on a Url object. The package also provides a FaupCompat class that mimics the original Faup C library's API for backward compatibility with legacy code.

The library targets developers who need fast, reliable URL decomposition—particularly in security, web scraping, or data processing pipelines where URL parsing is a frequent operation. It has no runtime dependencies and installs via pre-built wheels for most common Python and platform combinations, though source builds require a Rust toolchain.

Use it for:

- Extract domain and TLD from URLs in bulk for security scanning or threat intelligence workflows.
- Parse credentials, host, and port from URLs in web scraping or API client code.
- Normalize and decompose URLs in data pipelines for deduplication or classification.
- Migrate legacy code using the original Faup library to Python without rewriting URL parsing logic.
- Validate and decompose user-supplied URLs in web applications or CLI tools.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Parses URLs into components (scheme, host, port, path, query, credentials, domain, TLD) with a Rust backend for speed, offering both a modern API and backward compatibility with the legacy Faup C library.

Yes, if you need fast URL parsing in Python 3.8+ and can accept GPLv3 licensing. The Rust backend, zero runtime dependencies, and broad wheel coverage make it a low-friction choice for URL decomposition tasks. The active maintenance and recent release are positive signals. Avoid if your project requires proprietary licensing or if you are already satisfied with urllib.parse's performance.

## Install

pip install pyfaup-rs
uv add pyfaup-rs
poetry add pyfaup-rs

## Installing pyfaup-rs

Before you install: Medium install friction due to compiled wheels; pre-built binaries available for Python 3.10–3.11 across Linux, macOS, and Windows architectures. Active maintenance with a recent release (18 days old).

License in practice: Licensed under GPLv3 (copyleft); any derivative or distributed work must also be open-source under GPLv3. Acceptable for internal use and open-source projects, but incompatible with proprietary software that cannot adopt the same license.

Quickstart:

pip install pyfaup-rs

from pyfaup import Url
url = Url("https://user:pass@sub.example.com:8080/path?query=value#fragment")
print(url.scheme, url.host, url.port)

Requires Python 3.8 or later; pre-built wheels available for Python 3.10–3.11, source builds require Rust toolchain.

Verify before relying:

- Performance benchmarks comparing pyfaup-rs to urllib.parse or other URL parsing libraries.
- Whether the FaupCompat class is materially slower than the Url class in practice.
- Support status and timeline for Python 3.12+ wheels.

## Package facts

- License: GPL-3.0 (copyleft)
- Python support: supports_current
- Install friction: medium
- Maintenance: active
- Downloads: 92.5K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

url parsing library, parse url components, fast url parser, rust url parsing, extract domain from url, url scheme host port parser, faup python bindings, url-parsing, rust-bindings, security-tools

[View on SkillFed](https://skillfed.io/packages/pyfaup-rs) · [View on PyPI](https://pypi.org/project/pyfaup-rs/)