feedparser-rs
High-performance RSS/Atom/JSON Feed parser written in Rust, with Python and Node.js bindings. A drop-in replacement for Python feedparser that is 90-100x faster.
Features
- Multi-format support -- RSS 0.9x, 1.0, 2.0 / Atom 0.3, 1.0 / JSON Feed 1.0, 1.1
- Tolerant parsing -- Handles malformed feeds gracefully with the
bozo flag pattern, propagated at both feed and entry level
- HTML sanitization -- HTML-bearing fields (titles, summaries,
content:encoded, etc.) are sanitized by default to strip dangerous markup; opt out per-call for fully-trusted sources
- HTTP fetching -- Built-in URL fetching with compression (gzip, deflate, brotli) and conditional GET (ETag/Last-Modified)
- Podcast support -- iTunes and Podcast 2.0 namespace extensions, including
podcast:value/valueTimeSplit (feed- and item-level), podcast:chat, and podcast:podping
- JSON Feed extension objects -- generic capture of spec-sanctioned underscore-prefixed custom objects (e.g.
_cast) at feed- and item-level, exposed as json_extensions
- Security -- DoS protection via
ParserLimits, SSRF protection, input size validation
- Multi-language bindings -- Native Python (PyO3) and Node.js (napi-rs) bindings
- feedparser drop-in -- Dict-style access, field aliases, same API patterns as Python feedparser
Supported Formats
| Format |
Versions |
Status |
| RSS |
0.90, 0.91, 0.92, 1.0, 2.0 |
Full support |
| Atom |
0.3, 1.0 |
Full support |
| JSON Feed |
1.0, 1.1 |
Full support |
Namespace Extensions
| Namespace |
Description |
| Dublin Core |
Creator, date, rights metadata |
| Content |
Encoded HTML content |
| Media RSS |
Media attachments and metadata (media:content, media:thumbnail, media:title, media:description, media:credit, media:copyright, media:rating, media:keywords) |
| iTunes |
Podcast metadata (author, duration, explicit) |
| Podcast 2.0 |
Chapters, transcripts, funding, value/valueTimeSplit, chat, podping |
| Syndication |
Update schedule (period, frequency, base) |
| GeoRSS |
Geographic location data (Simple: point, line, polygon, box; GML profile: gml:Point/LineString/Polygon/Envelope/MultiSurface with srsName axis normalization) |
| Creative Commons |
License information with rel="license" links |
| Slash |
Comment count (slash:comments) |
| WFW |
Comment feed URL (wfw:commentRss) |
| Atom Threading (thr:) |
In-reply-to, reply count, reply datetime (RFC 4685) |
Installation
Rust
cargo add feedparser-rs
Or add to your Cargo.toml:
[dependencies]
feedparser-rs = "0.7"
[!IMPORTANT]
Requires Rust 1.91.0 or later (edition 2024).
Python
pip install feedparser-rs
[!NOTE]
Requires Python 3.10 or later.
Node.js
npm install feedparser-rs
# or
pnpm add feedparser-rs
[!NOTE]
Requires Node.js 18 or later.
Usage
[!IMPORTANT]
HTML-bearing fields are sanitized by default (matching Python feedparser's sanitizer). Use parse_with_options/parseWithOptions/parse(..., sanitize_html=False) to opt out for fully-trusted feed sources.
Rust
use feedparser_rs::parse;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let xml = r#"
<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>Example Feed</title>
<link>https://example.com</link>
<item>
<title>First Post</title>
<link>https://example.com/post/1</link>
</item>
</channel>
</rss>
"#;
let feed = parse(xml.as_bytes())?;
println!("Version: {}", feed.version.as_str()); // "rss20"
println!("Title: {:?}", feed.feed.title);
println!("Entries: {}", feed.entries.len());
for entry in &feed.entries {
println!(" - {:?}", entry.title);
}
Ok(())
}
Fetching from URL
use feedparser_rs::parse_url;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let feed = parse_url("https://example.com/feed.xml", None, None, None)?;
println!("Fetched {} entries", feed.entries.len());
Ok(())
}
[!TIP]
Use parse_url for URL fetching with automatic compression handling (gzip, deflate, brotli) and conditional GET via the etag/modified parameters.
Full control with ParseOptions
use feedparser_rs::{parse_with_options, ParseOptions, ParserLimits};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let xml = b"<rss version=\"2.0\"><channel><title>Example</title></channel></rss>";
let options = ParseOptions {
sanitize_html: false, // Trust this feed source
resolve_relative_uris: true,
limits: ParserLimits::strict(),
};
let feed = parse_with_options(xml, &options)?;
Ok(())
}
parse_url_with_options is the URL-fetching counterpart. See feedparser-rs-core for details.
Python
import feedparser_rs as feedparser # Drop-in replacement
# Parse from bytes, string, or URL (auto-detected)
d = feedparser.parse(b'<rss>...</rss>')
d = feedparser.parse('https://example.com/feed.xml') # URL auto-detected
# Attribute-style access
print(d.version) # 'rss20'
print(d.feed.title)
print(d.bozo) # True if parsing had issues
# Dict-style access (feedparser-compatible)
print(d['feed']['title'])
print(d['entries'][0]['link'])
# Deprecated field aliases work
print(d.feed.description) # -> d.feed.subtitle
print(d.channel.title) # -> d.feed.title
[!NOTE]
Python bindings provide full feedparser compatibility: dict-style access, field aliases, and time.struct_time for date fields.
Node.js
import { parse, parseUrl } from 'feedparser-rs';
// Parse from string
const feed = parse('<rss version="2.0">...</rss>');
console.log(feed.version); // 'rss20'
console.log(feed.feed.title);
console.log(feed.entries.length);
// Fetch from URL (synchronous)
const remoteFeed = parseUrl('https://example.com/feed.xml');
See Node.js API documentation for complete reference.
Cargo Features
| Feature |
Description |
Default |
http |
Enable URL fetching with reqwest (gzip/deflate/brotli support) |
Yes |
To disable HTTP support and reduce dependencies:
[dependencies]
feedparser-rs = { version = "0.7", default-features = false }
Workspace Structure
Development
# Install cargo-make
cargo install cargo-make
# Run all checks (format, lint, test)
cargo make ci-all
# Run tests with coverage
cargo make coverage
# Run benchmarks
cargo make bench
See all available tasks:
cargo make --list-all-steps
Benchmarks
Measured on Apple M1 Pro, parsing real-world RSS feeds:
| Feed Size |
Time |
Throughput |
| Small (2 KB) |
10.7 us |
187 MB/s |
| Medium (20 KB) |
93.6 us |
214 MB/s |
| Large (200 KB) |
939 us |
213 MB/s |
Format detection: 128 ns (near-instant)
vs Python feedparser
| Operation |
feedparser-rs |
Python feedparser |
Speedup |
| Parse 20 KB RSS |
0.09 ms |
8.5 ms |
94x |
| Parse 200 KB RSS |
0.94 ms |
85 ms |
90x |
[!TIP]
Run your own benchmarks with cargo bench or compare against Python with cargo make bench-compare.
MSRV Policy
Minimum Supported Rust Version: 1.91.0 (edition 2024).
MSRV increases are considered breaking changes and will result in a minor version bump.
License
Licensed under either of:
at your option.
Contributing
Contributions are welcome! Please read our Contributing Guide before submitting a pull request.
This project follows the Rust Code of Conduct.