# Bookmarks Parser MCP MCP

> The Bookmarks Parser takes messy HTML exports from Chrome, Safari, or Firefox and converts them into clean, structured JSON data. Instead of wading through unreadable code dumps, your AI client gets a usable hierarchy: folders, titles, and URLs—ready for analysis.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** bookmarks, data-parsing, json-conversion, digital-organization, browser-tools, file-processing

## Description

You've built up thousands of bookmarks over years. You export them to save them, but what you get back is usually a massive, messy HTML file that’s impossible for an agent to read correctly. If your AI tries to process raw browser exports, it wastes tokens and often hallucinates folder structures where none exist.

This MCP changes that. It uses a specific parser to take those legacy bookmark files—regardless of which major browser made them—and strip away all the junk code. What you get is perfectly structured JSON data. This means your agent can treat your entire digital life like a database, allowing it to accurately group links by topic, find every duplicate URL, or extract only the deep-nested resources you need.

Connecting this through Vinkius gives your AI client immediate access to clean, actionable data from all your saved links. It turns your bookmarks into something useful for tasks ranging from research analysis to content mapping.

## Tools

### parse_browser_bookmarks
Reads a messy Netscape Bookmark HTML file and converts it into structured JSON data for your agent to use.

## Prompt Examples

**Prompt:** 
```
Read my exported bookmarks.html and list all the duplicate URLs.
```

**Response:** 
```
I analyzed your bookmarks and found 14 duplicate URLs across 3 different folders. Would you like me to generate a script to remove them?
```

**Prompt:** 
```
Look at my bookmarks file and group all the links that look like AI tools into a new suggested folder structure.
```

**Response:** 
```
I've analyzed your 450 bookmarks. Here is a suggested folder structure for the 42 AI-related tools you saved:
- /AI Image Generators/
- /LLM APIs/
```

**Prompt:** 
```
Extract only the bookmarks from the 'Read Later' folder and format them as a Markdown list.
```

**Response:** 
```
Here is your 'Read Later' list:
- [TechCrunch Article](https://techcrunch.com/...)
- [React Documentation](https://react.dev/...)
```

## Capabilities

### Structure Link Data
The parser converts unstructured HTML exports into a reliable JSON object containing folders, titles, and URLs.

### Identify Duplicates
Your AI agent can scan the resulting JSON to pinpoint and list all duplicate links across different sections of your bookmarks.

### Map Folder Hierarchy
It correctly maps deeply nested folder structures, ensuring that context is preserved in the final data output.

### Extract Specific URLs
You can instruct your agent to pull out only links matching certain criteria (e.g., all academic papers or all GitHub repos).

## Use Cases

### Cleaning up pre-project research dumps
A product manager gathers hundreds of links from a competitor analysis and saves them haphazardly. Instead of manually reviewing the messy HTML file, they ask their agent to run `parse_browser_bookmarks` on the dump. The output allows the agent to instantly identify all duplicate sources and group the remaining unique links by topic for the next meeting.

### Mapping historical knowledge bases
A technical writer has years of saved documentation snippets in bookmarks from multiple projects. They run `parse_browser_bookmarks` to get clean JSON, allowing their agent to understand the full scope and hierarchy of all past reference material for a new manual.

### Auditing dead links on a website
A web developer compiles every internal link from a site into bookmarks. Using `parse_browser_bookmarks`, they get clean data that the agent can then cross-reference against an external crawler, pinpointing exact URLs that are no longer active.

### Preparing for content migration
A marketing team is moving old content to a new platform. They use `parse_browser_bookmarks` on their saved resource links. The resulting JSON allows the agent to filter and export only the high-priority, unique articles needed for the move.

## Benefits

- Stop dealing with raw HTML noise. The parser takes browser exports and strips away all the garbage code, leaving only folder names, titles, and URLs for your AI to consume.
- It accurately maps deep folder structures. You don't lose context when you have nested folders; the resulting JSON keeps that hierarchy intact for better organization.
- You can easily run checks for duplicates. By processing bookmarks with `parse_browser_bookmarks`, your agent finds and lists every repeated URL across all saved sections.
- It works universally. The parser handles native exports from Chrome, Safari, Firefox, Edge, and Arc, so you don't need separate tools for each browser.
- Your AI can act like a librarian. Instead of just listing links, it reads the structure to suggest grouping or categorize your saved content automatically.

## How It Works

The bottom line is you hand over a messy file path and get back usable, clean JSON data.

1. Provide the MCP with the absolute file path to your messy, exported HTML bookmark file.
2. The parser processes the raw HTML, translating its legacy format into a clean JSON object structure.
3. You receive structured data that contains only folders, titles, and URLs—ready for immediate use by your AI agent.

## Frequently Asked Questions

**Does it keep my nested folder structure?**
Yes! The parser strictly maintains the exact folder hierarchy (e.g., 'Work -> Q3 Reports -> Sales.pdf') so the AI understands exactly how your bookmarks are categorized.

**Is my browsing data sent to the cloud?**
No. The HTML parsing happens 100% locally on your machine. The engine only feeds the clean JSON representation back to your AI chat context.

**Can it identify broken links or 404 pages?**
While the parser itself just extracts the URLs local, you can subsequently ask Claude to use a network tool to test if the extracted links are still active.

**When I run `parse_browser_bookmarks`, do I have to use Chrome, or does it support other browsers?**
No, you don't just have to use Chrome. This MCP supports native exports from Google Chrome, Safari, Firefox, Edge, and Arc, giving you universal coverage for your bookmarks.

**How exactly do I provide the file path when I call `parse_browser_bookmarks`?**
You must provide the absolute file path to the exported .html file. Your AI client uses this exact path to access and process your bookmark data.

**If my original HTML export is corrupted, what happens when I run `parse_browser_bookmarks`?**
The parser includes robust error handling for malformed files. It will flag the corruption issue and attempt to parse all valid sections it can find.

**Can I process a very large number of bookmarks when calling `parse_browser_bookmarks`?**
The MCP is designed for high volume processing. It handles thousands of entries, ensuring your agent gets the full structured JSON hierarchy without hitting token limits.

**Does `parse_browser_bookmarks` only output JSON structure, or can I request a different format like CSV?**
It outputs clean, structured JSON data. This ensures the resulting file is perfectly hierarchical and ready for any downstream AI task that expects structured records.