Parsio

Copy one or more parsing templates into a target mailbox -- the way to reuse a trained template across mailboxes without retraining it. Takes the template ids and the destination `mailbox_id`.

Import text or HTML into a mailbox and return as soon as the document is queued, without waiting for parsing. Answers 201 carrying the new document's id as a bare JSON string. Collect the result later with Get a document, or let a webhook deliver it. Prefer this over the synchronous variant when you already use webhooks or want the fastest possible reply.

Import text or HTML into a mailbox and wait for the parsed result in the same response. This is the endpoint to prefer when you already have the content as text or HTML and you want the extracted fields back immediately: the reply carries `json` with the parsed fields, alongside `doc_id` and `status`. It blocks while Parsio parses. If parsing outruns Parsio's own timeout the reply is still 201 but carries `parsing_in_progress: true` with a null `json` -- that is not a failure, and the result is fetched afterwards with Get a document.

Create a new parsing mailbox. Only `name` is required; Parsio assigns the inbound email prefix and the remaining defaults itself and returns the whole created mailbox, including the `_id` to pass to every other operation. Answers 201.

Register a webhook on a mailbox so Parsio POSTs parsed documents to your endpoint as they finish. Answers 201 with the created webhook, including the `_id` you need to update or delete it and the `secret` Parsio signs its deliveries with.

Permanently delete a mailbox and everything it owns -- its documents, templates and webhooks go with it. Answers 200 with an empty body. There is no trash and no undo: confirm the id against List mailboxes before calling this.

Permanently delete one or more parsing templates by id. The ids travel in the request BODY, not the path or the query -- this is a DELETE with a JSON body. Answers 200 with `true`. There is no undo, and a deleted template must be retrained.

Permanently delete one or more webhooks by id. The ids travel in the request BODY -- this is a DELETE with a JSON body. Answers 200. Deliveries stop immediately and the signing secret is gone with the webhook.

Disable one or more parsing templates by id, so the parser stops matching documents against them without deleting them. Answers 201.

Enable one or more parsing templates by id, so the mailbox's parser starts matching incoming documents against them again. Answers 201.

Fetch one document as JSON -- the same payload shape Parsio's webhooks deliver, including the parsed fields. This is how you collect the result of an asynchronous import, and how you finish a synchronous one that answered `parsing_in_progress: true`. An unknown id answers 200 with an EMPTY body rather than 404, so treat an empty reply as 'no such document', not as a document with no fields.

Read one mailbox's settings and configuration -- its parser `preset`, `ml_model`, email prefix, retention, alerting and current `stats`. Use it to discover which parser a mailbox runs before importing into it, because the text/HTML import endpoints only work on template-based and GPT-powered parsers.

Read one parsing template. An unknown id answers 200 with an empty body rather than 404, so treat an empty reply as 'no such template'.

Read one webhook -- its url, event, enabled flag, `table_id` and signing `secret`. An unknown id answers 200 with an empty body rather than 404.

List the email addresses Parsio collected for a mailbox. Only populated when the mailbox has `collect_emails` switched on; answers an empty array otherwise.

List a mailbox's documents, newest first, in a paged envelope (`docs`, `totalDocs`, `page`, `totalPages`, `hasNextPage`). Filter by status, by name, and by date. This is the operation that reconciles an import whose reply was lost: search for the document by name rather than importing it again.

List the table fields defined on a mailbox. A table field is what a `table.parsed` webhook fires on, and its id is the `table_id` that webhook needs. Answers a JSON array, empty when the mailbox defines no table fields.

List every Parsio mailbox the API key's account can reach. A mailbox is the parsing workspace: it owns a parser type, its templates, its documents and its webhooks, and its `_id` is the `mailbox_id` every other operation here takes. Answers a JSON ARRAY, not a paged envelope.

List the EXTRACTED FIELDS for a mailbox's documents, rather than the documents themselves -- one object of parsed values per document, in a paged envelope whose `docIds` array lines up with `docs`. This is the operation to read when you want the data Parsio pulled out; List documents gives you the documents' metadata instead.

List the parsing templates defined on a mailbox, in a paged envelope. Templates belong to the template-based parser; a GPT-powered or AI-powered mailbox legitimately has none and answers an empty page.

List every webhook registered on a mailbox. Answers a JSON array. Note the `/mb/` segment -- it is what separates this from Get a webhook, which takes a webhook id at the same depth.

Queue a document for reprocessing -- the way to re-extract after changing a template or switching the mailbox's parser. Answers 201 with a bare number, which is a queue handle and not a document id. Reprocessing is asynchronous: poll Get a document for the new result.

Mark documents as skipped so Parsio stops trying to parse them. Takes a list of document ids and answers 201 with `true`. Use it to clear a backlog of documents that will never parse -- a wrong-format import, or a batch that belongs to another mailbox's template.

Update a mailbox's settings. This is a POST, not a PATCH or PUT -- Parsio has no other update verb for a mailbox, and `PUT /mailboxes` does not exist. Both `name` and `email_prefix` must be sent on every call, even when only one of the other fields is changing, so read the mailbox first and send its current values back.

Update an existing webhook. The webhook's id travels in the BODY as `_id`, not in the path -- the path carries no id at all, which is what distinguishes this from Create a webhook. Send the full set of fields: `_id`, `url`, `event` and `table_id` are all required on every call.

Upload one file and return as soon as it is queued, without waiting for parsing. Answers 201 carrying the new document's id as a bare JSON string. This is the variant that accepts ZIP archives, and its ceiling is 50 MB rather than 20 MB -- though this tool's own 4 MiB inline bound applies first. Collect the result with Get a document or through a webhook.

Upload one file -- PDF, scanned PDF, image, DOCX, CSV, XML and the other formats the mailbox's parser supports -- and wait for the parsed result in the same response. The reply carries `json` with the extracted fields alongside `doc_id`, `status` and `content_type`. Works with every Parsio parser type, as long as the mailbox's type supports the format. ZIP is NOT accepted here; use the asynchronous upload for that. Parsio's own ceiling is 20 MB, one file per request. As with the other synchronous endpoint, a reply carrying `parsing_in_progress: true` means parsing outran the timeout and the result is fetched afterwards with Get a document.