# OPML Podcast & RSS Parser MCP > OPML Podcast & RSS Parser uses your OPML export files to turn messy podcast and RSS feed lists into clean, structured JSON data. Stop wrestling with verbose XML tags; this server flattens the hierarchy so your AI agent can actually read your subscriptions and curate content. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** rss, podcast-management, xml-parsing, data-transformation, content-curation, subscription-management ## Description Listen up. If your AI client needs to recommend content—whether it’s the next killer podcast or an article you gotta read—it can't just stare at a dump of XML tags. You know the drill: you export your entire library from Apple Podcasts, Pocket Casts, Feedly, or whatever reader you use. What you get back is messy. It's recursive garbage; it's verbose and bloated with tags that mean nothing to an agent trying to parse data. That’s where this server comes in. This isn't some fancy piece of fluff designed to impress your grandma. It's a straight-up parser built for agents. Its job is simple: take that gnarly `.opml` file and flatten the entire thing into something usable—a clean JSON array. The key here is data structure. LLMs don’t read nested XML trees like a human does; they choke on them. They get lost in attributes and namespaces. This server cuts through all that noise, stripping out everything extraneous so your agent can actually focus on the subscription titles and feed URLs it needs to know. When you use `parse_opml_feeds`, you give it the path to your exported OPML file. It doesn't waste time trying to guess what you want; it just spits out a straightforward JSON list of every single podcast or RSS feed subscription it finds in that export. That’s it. A simple, flat array. Think about what happens when you use this data. Instead of having your agent struggle with deeply nested XML structures—the kind where one tag needs three levels of indentation just to define a date—you give it clean, predictable JSON. The output is a list that reads like a shopping receipt: 'You subscribed to X,' 'You subscribed to Y,' and so on. It's crucial for agents because they need reliable input. If the data format changes or gets too complex, your workflow breaks down. This server guarantees it won't. It takes the raw output from any major podcast client—the ones that generate those beastly OPML files—and standardizes the payload immediately. The process is straightforward: you provide the file path to `parse_opml_feeds`, and the tool returns a clean JSON list containing every single subscription found in the source feed. This means your agent can instantly get a complete inventory of your content interests without ever having to parse or understand the underlying, messy XML markup. It’s local too, which is huge for privacy-conscious folks like us. Your whole subscription history stays parsed locally; nothing gets sent out to some public server farm. You run this on your end, you get clean data back to your agent, and it's done. It means that when you need to build a specialized tool—maybe one that curates content recommendations based solely on the feeds you follow—you don't have to write a complex XML parsing routine yourself. The server handles the dirty work of flattening the hierarchy. This capability is essential for turning your personal listening habits into actionable data. You get back a simple JSON array listing all subscriptions, perfect for feeding directly into an AI agent that needs to process this list—maybe it's tracking metadata, checking feed health, or just building out a consolidated content map. The tool doesn't care if the original file came from Pocket Casts or iTunes; as long as it follows OPML standards, `parse_opml_feeds` gets you clean data. It’s about transforming that verbose XML bloat into an agent-ready list of feeds. Your AI client needs a simple array of strings and objects, not nested tags. This server gives it exactly that. It's the necessary pre-processing step for any sophisticated content curation workflow your agent might run. ## Tools ### parse_opml_feeds Takes an OPML file path and outputs a simple JSON array listing all subscriptions from the podcast or RSS feed export. ## Prompt Examples **Prompt:** ``` Read my podcasts.opml file and recommend 3 new tech podcasts I might like. ``` **Response:** ``` Based on your 15 current tech subscriptions (like Lex Fridman), I highly recommend: 1. Hard Fork, 2. Syntax, 3. The Vergecast. ``` **Prompt:** ``` Extract all the RSS URLs from my Feedly export and format them as a Markdown table. ``` **Response:** ``` | Title | RSS Feed URL | |-------|-------------| | Wired | wired.com/feed | | TechRadar | techradar.com/rss | ``` **Prompt:** ``` Analyze my OPML file and tell me what my primary interests are. ``` **Response:** ``` Looking at your 45 subscriptions, your primary interests are: 1. Artificial Intelligence (12 feeds), 2. Economics (8 feeds), 3. Design (5 feeds). ``` ## Capabilities ### Extract Subscription List Provides the file path, and the tool returns a clean JSON list of every podcast or RSS feed subscription found in the OPML export. ## Use Cases ### Analyzing a client's media profile A marketing analyst receives an `.opml` file of a target client’s subscriptions. Instead of manually reading hundreds of messy RSS links, the agent calls `parse_opml_feeds`. The resulting JSON list lets the AI immediately categorize interests (e.g., 12 feeds in 'Finance,' 5 in 'Gaming') and suggest highly targeted ad campaigns. ### Building a knowledge graph from research sources A researcher exports OPML files combining academic journals, industry reports, and personal blogs. The agent uses `parse_opml_feeds` to clean the messy input into one flat list. This allows the AI client to build an accurate content map of the researcher's entire intellectual focus. ### Generating curated reading lists A personal assistant has a large, raw feed export. The agent calls `parse_opml_feeds` first. Then, it processes the clean list to identify gaps—like missing feeds in 'Sustainable Energy'—and recommends three specific, highly relevant new podcasts. ### Formatting data for a database upload A content team collects dozens of RSS feed exports. They use `parse_opml_feeds` to process each one into structured JSON records. This eliminates the need for manual XML cleanup and prepares the clean array for bulk ingestion into a CRM or CMS. ## Benefits - **Saves tokens and time:** Instead of sending your AI client massive files full of redundant XML tags, the `parse_opml_feeds` tool flattens everything. Your agent gets a compact JSON array—no token waste. - **Guarantees clean data:** The parser uses a deterministic method to drop all unnecessary attributes and markup. You don't have to write complex parsing logic; just point your agent at the file. - **Enables deep analysis:** With structured subscription lists, your AI client can accurately analyze patterns—like determining if 80% of feeds relate to 'Artificial Intelligence.' - **Maintains privacy:** Because the parsing happens locally, you don't risk uploading sensitive details about what podcasts you listen to. The data stays yours. - **Handles all sources:** It supports OPML files from any major podcast player or RSS reader, meaning it works no matter where your content feed came from. ## How It Works The bottom line is you get predictable, machine-readable data instead of messy XML code. 1. First, give your AI client the absolute file path to the `.opml` file (the podcast/RSS feed export). 2. The MCP server runs a fast XML parser that reads the complex OPML structure and strips away all the unnecessary tags. 3. Your agent receives a simple JSON array containing only the clean, structured list of subscriptions. ## Frequently Asked Questions **What file types can the OPML Podcast & RSS Parser use?** It requires an `.opml` file. This format comes from standard podcast players or RSS readers when you export a list of your subscriptions. **Is using the parse_opml_feeds tool safe for my data privacy?** Yes, the parsing happens locally. Your subscription habits are processed on your end and are not uploaded to any public server. **Does OPML Podcast & RSS Parser handle every kind of feed?** It handles feeds exported from standard podcast players or RSS readers that use the OPML format. It's designed for structure, not content type validation. **How many tools are in the OPML Podcast & RSS Parser MCP Server?** There is one core tool: `parse_opml_feeds`. This single tool handles all the necessary parsing logic to convert your feed export into usable data. **What is the processing speed of the parse_opml_feeds tool?** The parser uses a fast, deterministic XML engine. It flattens complex OPML structures into JSON quickly, even with large files. This efficiency minimizes token waste and keeps your agent running smoothly. **What kind of input does the parse_opml_feeds tool require?** The tool requires you to provide the absolute file path to the OPML export. It needs this specific location reference to read the data and begin parsing your subscriptions. **What is the structure of the JSON output from parse_opml_feeds?** The resulting JSON is a clean, flat array. The tool removes all unnecessary XML tags and attributes, giving you only a simple, structured list of your subscriptions for easy AI consumption. **Can the OPML Podcast & RSS Parser handle non-standard feeds?** The parser handles standard OPML exports from major players. While it's universal, complex or heavily customized XML structures may require manual cleanup before running parse_opml_feeds. **Does it support nested subscription categories?** Yes! It recursively scans through folder nodes (like 'Tech News' -> 'AI') in the OPML file to extract the actual feed URLs, flattening them into a clean list for the AI. **What specific data is extracted?** It extracts the Title, the XML (RSS) URL, and the HTML (Website) URL for every single subscription found in the file. **Can it subscribe to new podcasts for me?** No, this is a read-only parsing tool. It allows the AI to understand what you currently listen to so it can make intelligent recommendations.