# Parseur MCP for AI Agents AI Agent Connect

> Parseur turns your unstructured documents into clean, usable data automatically. Instead of manually copy-pasting numbers from PDFs or emails into a spreadsheet, your AI agent can handle the entire pipeline for you. It handles the heavy lifting of identifying fields, mapping them to your specific needs, and delivering the results in a format your other apps can actually use.

## Overview
- **Category:** productivity
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_6MExFCZztxj2EawHbJwpL4Z4EKWcXn1vrBkxx1fJ/ai-agent-connect
- **Tags:** ocr, data-parsing, email-automation, pdf-processing, template-extraction, structured-data

## Description

Parseur lets you turn unstructured documents into clean data automatically. Instead of manually copy-pasting numbers from PDFs or emails into a spreadsheet, your AI agent can handle the entire pipeline for you. By connecting to Parseur's OCR and templating engines, your agent can take messy files like invoices, receipts, or scanned forms and push them into a parsing queue. It identifies the specific fields you need and delivers them back as structured data ready for your database or app.

This means you can stop acting as a data entry clerk. You can build systems that monitor specific mailboxes, track the status of documents as they move through the engine, and even handle retries when a parse doesn't go perfectly. Because Vinkius makes it so easy to connect these tools, you can set up these workflows in minutes. Whether you're trying to clear out an inbox of utility bills or digitize a mountain of paper applications, this Connector gives your agent the eyes it needs to read and organize your paperwork without you having to lift a finger. You can move from a world of manual file management to one where your agent identifies the total amount, the date, and the line items from a photo or a scan and puts them exactly where they belong. It handles the messy work of reading the text so you can focus on what to do with the information once it's organized.

## Tools

### get_document_data
Pull the full JSON data from a document that has finished the parsing process. This includes fields like invoice numbers or totals.

### get_document_details
Retrieve the metadata and status of a specific document without pulling the full data. Use this to check processing progress.

### get_mailbox
Check the configuration of a specific mailbox to ensure it's set up correctly. Use this to verify settings before sending files.

### list_documents
See a list of all documents in a mailbox along with their current processing status. Each entry includes the document ID and status.

### list_templates
See all the extraction rules currently available for a specific mailbox. This helps you identify which templates are ready for use.

### retry_document
Re-run a document through the parser to see if it now matches the latest template rules. This is useful for fixing failed parses.

### upload_document
Send a document URL to a specific mailbox so it can be queued for automatic OCR. It returns a new document ID for tracking.

### create_mailbox
Set up a new parsing pipeline for a specific type of document like PDFs or emails. You can configure templates for it immediately.

### create_template
Create a new set of rules to define which fields the engine should extract from your documents. Pass a JSON config for field mappings.

### list_mailboxes
View all your active parsing pipelines to see which mailboxes are available for use. Each mailbox represents a specific document type.

## Prompt Examples

**Prompt:** 
```
Check my Parseur mailboxes to find the specific bounding IDs.
```

**Response:** 
```
I've checked your Parseur mailboxes. I found 2 active pipelines:

1. **Invoices Mailbox** (ID: xyz12) for PDF accounting payloads.
2. **Web contact forms** (ID: wtf9).

Would you like me to list the templates for either of these?
```

**Prompt:** 
```
Get the data schema parsed tightly inside document doc_987.
```

**Response:** 
```
I've pulled the data for document doc_987. It was parsed successfully. Here are the extracted fields:

| Field | Value |
| :--- | :--- |
| **Invoice Number** | A-201 |
| **Total Amount** | 1400.99 |
| **Date** | 2026-04-10 |

Everything looks correct.
```

**Prompt:** 
```
Upload this snippet of parsed text directly into Mailbox xyz12 for OCR processing.
```

**Response:** 
```
I've successfully pushed that snippet to the 'Invoices Mailbox' (ID: xyz12). The document has been queued for parsing and was assigned the ID: doc_112. I'll let you know as soon as the results are ready.
```

## Capabilities

### Upload files for OCR
Send PDFs or email files to a specific mailbox for automatic data extraction.

### Extract structured JSON
Get the exact fields you need from a document in a format your apps understand.

### Manage parsing mailboxes
Create and organize different pipelines for different document types like receipts or forms.

### Define extraction rules
Set up specific templates to tell the engine exactly which data points matter most.

### Retry failed parses
Automatically re-run documents that didn't process correctly to ensure your data is complete.

### Track document status
Check if a file is still pending, successfully parsed, or needs a manual look.

## Use Cases

### Automated Invoice Processing
An AP clerk asks the agent to take all invoices from a specific email and put the totals into a spreadsheet. The agent uses upload_document and get_document_data.

### Receipt Reconciliation
A travel manager asks the agent to find the total spent on all receipts in a folder. The agent lists the documents, checks statuses, and sums the totals.

### Form Digitization
An HR manager wants to extract the name and start date from a batch of scanned applications. The agent processes the batch and returns a clean list.

### Webhook Integration
A developer wants to send uploaded PDFs to a backend via Parseur. The agent handles the upload and monitors the success via the list_documents tool.

## Benefits

- Eliminate manual data entry: Use upload_document to move files into a queue, saving hours of manual typing every week.
- Standardize messy inputs: Use create_template to ensure that every invoice or receipt follows the exact same data format every time.
- Improve data accuracy: Let the OCR engine handle the heavy lifting of reading text, reducing the risk of human typos in your records.
- Scale your processing: Handle hundreds of documents at once by using list_documents to monitor the status of your entire queue.
- Recover from errors: Use retry_document to quickly re-process files that failed due to transient errors without manual re-uploading.

## How It Works

The bottom line is you turn unstructured documents into usable data without ever opening a PDF again.

1. Connect your Parseur API key to the Connector.
2. Create mailboxes and templates for your specific document types.
3. Have your AI client send documents to these mailboxes and pull back the extracted data.

## Frequently Asked Questions

**What does Parseur do for my business?**
Parseur turns your unstructured documents, like PDFs and emails, into structured data. It uses OCR to read the contents and extracts specific fields like totals or dates so your AI agent can use them in other apps.

**Can I use Parseur to automate my invoice processing?**
Yes, that's one of its primary uses. You can set up a mailbox for invoices, have your agent send them to Parseur, and then automatically pull the extracted data into your accounting software.

**Does Parseur work with handwritten receipts?**
Yes, because it uses a powerful OCR engine, it can often identify text in photos or handwritten documents and convert them into digital data for your agent to process.

**How does the Parseur MCP help with data entry?**
It replaces manual typing. Instead of a human reading a PDF and typing it into a system, the Connector lets your AI agent handle the upload and data extraction automatically.

**Can I manage multiple types of documents at once?**
Absolutely. You can create different mailboxes for different document types, like receipts, invoices, and forms, and use specific templates for each one.

**What happens if a document fails to parse?**
If a document doesn't process correctly, you can use the Connector to trigger a retry. This forces the engine to re-examine the file against your current template rules.

**Does this tool parse the document directly or use the cloud engine?**
The tool offloads the logic specifically via endpoints mapping back to the Parseur Cloud Engine. The AI acts to organize mailboxes, list templates, and fetch final states securely without computing massive local OCR networks.

**Can I upload a raw file string to be parsed?**
Yes. Utilizing the explicitly mapped `upload_document` constraint, the agent can inject raw string boundaries identifying formatting, passing files straightforward into the target mailbox ID natively.

**Will I see missing required fields if extraction fails?**
Absolutely. Querying `get_document_details` lists specific status bounds. If a template expects InvoiceTotal and misses it, the document flags a processing boundary issue precisely traceable here.