Parseur

Delete one document and its parsed result. Measured: Parseur answers 204 and the document is gone immediately -- absent from its mailbox's collection and 404 at its own address. There is no recycle bin, and deleting a document does not refund the page it consumed

Delete a mailbox and everything in it -- every document, every template and every custom download. Parseur answers 200 with `{"notification_set": {"info": ["Mailbox is being deleted. This can take a while."]}}` and removes it asynchronously, so a read-back may briefly still find it before it 404s. There is no undo and no recycle bin

Remove one custom download configuration from a mailbox. Answers 204. The mailbox, its documents and its parsed results are untouched -- only the named export definition is deleted, and any link built from it stops working

Detach a webhook from one mailbox so that mailbox stops firing it. DESPITE THE HTTP VERB THIS DOES NOT DELETE THE WEBHOOK: the webhook survives at the account level and stays enabled on every other mailbox. Use Delete a webhook to remove it entirely

Delete one parsing template. Answers 204. Documents already parsed keep their results, but nothing new will match this template again -- so a mailbox whose only template is deleted starts failing to parse everything it receives

Delete a webhook from the account entirely, detaching it from every mailbox it was enabled on. This is the destructive counterpart of Disable a webhook on a mailbox, which only detaches it from one

Fetch Parseur's own configuration reference: the allowed values for every enumerated setting (document statuses, AI engines, date and decimal formats, log sources), the field-format mappings a template may use, the maximum field lengths, the catalogue of master templates (Invoices, Bank Statements and the rest) and `email_domain`, the domain mailbox addresses are formed on. Read it before creating or updating a mailbox so the settings you send are values Parseur accepts. This endpoint answers WITHOUT a credential, so it keeps working even when a connection's key is wrong, and it is account-independent

Fetch one document by id: its status, the mailbox it arrived in, its original metadata (sender, subject, recipient) and the fields Parseur extracted from it. This is how to read a parsed result after the Upload a document tool returns a DocumentID

List the processing events recorded for one document -- what Parseur did, when, which template matched and why an export or webhook succeeded or failed. This is the tool to reach for when a document's status is PARSEDKO or EXPORTKO and the question is why

List the Parseur mailboxes on the connected account, each with its id, name, `email_prefix`, document counts by status, template count and parsing settings. This is where a mailbox id comes from for every other tool here, including the id the Upload a document tool requires. Paginated with `page` and `page_size`; `search` matches the name case-insensitively and `ordering` takes a field name with a `-` prefix for descending

Fetch one mailbox by id, with its full parsing configuration: the AI engine, the metadata fields that are enabled, the allowed file extensions, page-range and splitting rules, the retention policy and its `email_prefix`. An id the connected credential does not own answers 404 "Mailbox not found" rather than 403, so Parseur hides the existence of other accounts' mailboxes

List the documents a mailbox has received, newest first by default, each with its id, name, status and parsed result. Filter by `status` (PARSEDOK, PARSEDKO, QUOTAEXC, SKIPPED and the rest), by `received_after`/`received_before` as `yyyy-mm-dd`, or by a case-insensitive `search`; `tz` sets the timezone the date filters are read in and defaults to UTC. `page` and `page_size` paginate

List the custom download configurations on a mailbox -- the named CSV, Excel and JSON exports that choose which parsed fields appear and in what order. Each entry carries its id, name, type and the field items it selects

Fetch the JSON schema of the fields this mailbox extracts -- the names, types and formats its templates produce. This is the contract a consumer of the parsed results should read before mapping them, and the fastest way to see what a mailbox actually captures without fetching a document

List the parsing templates defined on a mailbox, each with its id and name. Templates are what turn a received document into named fields, so a mailbox with none parses nothing. Pair with Get a mailbox's parsed-field schema to see what the template set actually produces

Fetch one parsing template by id, with the field definitions it captures and the rules it matches on. The id comes from List templates in a mailbox

Change one custom download on a mailbox -- its name, its type or the fields it selects. A PATCH, so send only what is changing. Takes both ids: `mailbox_id` for the mailbox and `id` for the download itself, which the List custom downloads tool returns

Copy one document into another mailbox on the same account, where it is parsed against THAT mailbox's templates. Both ids must belong to the connected account. Use it to test a document against a different template set without re-uploading it; the copy is a new document and consumes a page in the target mailbox

Re-run parsing on a document that has already been received, against the mailbox's CURRENT templates. Use it after fixing or adding a template so an already-failed document is parsed again without being re-uploaded. Reprocessing an existing document does not consume another page

Mark a document SKIPPED so Parseur stops trying to parse it and stops reporting it as a failure. The document and its metadata stay; only the parsing attempt is abandoned. This is the way to clear a document that will never match a template out of the failure counts

Upload an email or text document into one of THIS connection's mailboxes and have Parseur parse it. `mailbox_id` names the destination and comes from the List mailboxes tool; the document itself is the `body` -- `subject`, `from`, and `body_plain` or `body_html`, plus optional `to`, `cc`, `bcc` and `message_headers`, which are recorded as the document's metadata. SPENDS A PAGE OF THE ACCOUNT'S PARSING QUOTA on every successful call, and the free tier is 20 pages a month -- a retry loop is a billing event. Returns the new DocumentID; read the parsed result with Get a document once its status leaves PROGRESS. You cannot address a mailbox outside this connection: the id is resolved with your own credential first, and Parseur answers 404 for a mailbox the credential does not own

Create a new Parseur mailbox. A mailbox is the unit that receives documents and holds the templates that parse them. Only `name` is needed in practice -- every other field has a default, and Parseur generates the id, the account uuid, the `email_prefix` and the download URLs itself. Do not send any of those generated fields: Parseur answers 400 "Unexpected field." for the read-only collections

Duplicate a mailbox, with its templates and parsing settings, into a new mailbox on the same account. The copy gets its own id and its own `email_prefix`, so documents sent to the original are unaffected. Useful for versioning a template set before editing it

Add a custom download to a mailbox: a `name`, a `type` (which export format it produces) and the `items` naming the parsed fields it includes and their order. Parseur generates the id and the download URLs, so do not send them. Answers 409 when a download of that name already exists on the mailbox

Attach an existing webhook to a mailbox so that mailbox's events start firing it. Takes the `mailbox_id` and the webhook's `id`. The webhook itself is account-level and can be enabled on several mailboxes

Copy one parsing template into another mailbox on the same account, leaving the original in place. Both ids must belong to the connected account. This is how a template that works on one mailbox is reused without rebuilding it

Create a webhook on the account: the `event` it fires on, the `target` URL it posts to, its `category` and optional `headers` and a `parser_field_set` narrowing which parsed fields are sent. Parseur generates the id, so do not send one. Creating a webhook does not attach it to a mailbox -- use Enable a webhook on a mailbox for that

Replace a mailbox's settings: its name, AI engine and instructions, which metadata fields are enabled, allowed extensions, splitting and page-range rules, retention and the sender allow/deny list. This is a PUT, so send the whole configuration you want rather than only the fields you are changing. Parseur generates the id, account uuid, `email_prefix` and download URLs and refuses to be sent them