Parsio

Import PDFs, scanned documents, and emails into Parsio, an AI-powered parser, and pull structured fields back. Agents turn inbound paperwork into typed data the moment it arrives.

1 trigger 11 actions API key available

Platform Documentation ↗ Capability data verified 2026-07-31

On Document Event fires on Table Parsed when a purchase order's line items finish extracting

Agent reads the repeating rows plus the document-level fields with Get Document

Agent checks that every row carries a SKU the catalogue recognises and a quantity above zero

Agent creates the sales order in [NetSuite](/integrations/netsuite) from the extracted rows

Order desk in [Slack](/integrations/slack) receives the created order and the source document

Rows with an unrecognised SKU, and any batch an agent wants to skip, wait for the order desk

What This Integration Enables

Parsio is a mailbox, and that framing is the whole design. Documents arrive because they were emailed to the mailbox address, uploaded by a person, or imported by an agent, and all three paths land in the same place with the same templates applied. The mailbox type decides how extraction happens: template-based, GPT-powered, the AI parser, or the OCR converter. That matters in practice, because Parse Text or HTML is supported only by the template-based and GPT-powered types, while the AI parser and OCR converter need a real file.

The part worth building around is the trigger. On Document Event subscribes to one specific Parsio event rather than to documents in general, and the choices are meaningfully different: a document was received, a document was parsed, a document was parsed into flattened JSON, a document failed to parse, or a table field finished extracting its rows. Subscribing to Table Parsed rather than to Parsed is the difference between a flow that has the invoice header and a flow that has the line items. FlowRunner connectors let an agent pick the event that matches the work, then act on it, which is a good deal more precise than reacting to everything and filtering in code.

Without FlowRunner

Line items arrive last and late The flow reacts to a parsed document and then waits for the table nobody told it about

Failures pile up quietly Documents no template matched sit in a failed queue that nobody owns

Cleanup is guesswork Removing junk imports means deciding in bulk what nobody has looked at

With FlowRunner

Events match the work The flow subscribes to the specific Parsio event it acts on, including table extraction

Failures are a routed queue The failed event becomes work with an owner instead of a status somebody may notice

Bulk removal is approved Taking documents out of the pipeline is a decision a person makes, not a cleanup side effect

Use Case Scenarios

Purchase orders where the rows are the point

Customers email purchase orders to the mailbox in whatever format their own system produces. The agent subscribes to Table Parsed on the mailbox's line-item table field, so it wakes up when the rows exist rather than when the header does. It reads the document with Get Document, checks each row's SKU against the catalogue and each quantity for sanity, and creates the sales order in NetSuite. A row with a SKU nobody recognises does not become a line on an order; it becomes a question in the order desk channel with the source document attached.

Failed parses as a routed queue instead of a graveyard

A second flow subscribes to the parse-failed event on the same mailbox. When no template matched a document, the agent pulls it, posts it to ops in Microsoft Teams with the filename, sender and date, and offers the two real options: fix the template and reprocess, or handle it manually. Once a template is corrected, Reprocess Document re-runs extraction on the documents that failed, without anyone re-sending anything. The failed queue stops being a place documents go to be forgotten and becomes an automation exceptions feed with an owner.

Exporting a day's parsing in one call

Finance wants the day's parsed invoices as a single dataset rather than as a stream of events. A scheduled agent calls Get Parsed Data with the mailbox and a date range, which returns the extracted data for every document as a paginated dataset instead of fetching them one at a time. The agent writes the result into Google Sheets for the reconciliation tab and into Snowflake for the warehouse, and the same call covers both because the extraction only happened once.

Human-in-Loop Highlight

The Parsio public API has no endpoint for deleting a document. Skip Documents is the supported way to take documents out of the parsing pipeline, and it does two things at once: Parsio stops processing them, and they stop counting towards the parsing quota. That combination makes bulk skipping quietly attractive to an agent doing cleanup, and quietly dangerous, because there is no documented reverse for it and the API offers no second chance elsewhere. Forty documents skipped in one call is forty documents that no downstream flow will ever see again, and nothing about the mailbox afterwards indicates that they were there.

So a FlowRunner agent never skips in bulk on its own reasoning. It builds the case and hands it over. It posts the exact list to the mailbox owner with filenames, senders, dates and current statuses, and states its own inference and its own uncertainty: "These forty documents in the AP mailbox are all failed, all from the same sender, and all appear to be re-forwards of the same monthly statement between the fourth and the seventh. I want to skip them. Two of them have different totals, so I am not certain they are duplicates. Skip all forty, skip the thirty-eight that match, or leave them for review?" The owner picks. The distinction that matters is not whether an agent could do it, but whether an irreversible bulk removal should ever be a side effect of a cleanup job rather than a decision somebody made on purpose.

Agent processes routinely

Detects exception requiring judgment

Clear match Continues automatically

Ambiguous Routes to human via preferred channel

Human decides

Agent resumes with decision

Agent Capabilities

11 actions

Mailboxes

List Mailboxes Returns every Parsio mailbox available to the key with its identifier, name and inbound email address. A mailbox holds your parsing templates and the documents imported into it, so its ID is required by nearly every other operation here.
Get Mailbox Retrieves one mailbox's settings: name, email prefix, parser preset and attachment handling. Agents read it to see how a mailbox will treat incoming documents before importing into it.
List Table Fields Lists the table fields configured in a mailbox. Table fields hold the repeating rows extracted from documents such as invoice line items, and their identifiers are what the trigger needs when subscribing to the Table Parsed event.
List Collected Emails Returns the email addresses Parsio has automatically collected from documents received by a mailbox. Collection only happens where the mailbox has the option enabled, so an empty list means the setting rather than the absence of senders.

Documents

Parse File Downloads a file from a URL and imports it into a mailbox for extraction, returning the structured fields. Supports PDFs, scanned PDFs, images, DOCX, CSV, Excel, XML and more depending on the mailbox parser type. With Wait For Result enabled the call is synchronous, one file per request and no ZIP archives; disabled, it returns immediately with a document ID, allows larger files and accepts ZIP archives.
Parse Text or HTML Imports content already held as plain text or HTML without uploading a file, returning the extracted fields. Supported only by template-based and GPT-powered mailboxes, because the AI parser and the OCR converter need real bytes. When both HTML and text are supplied, Parsio parses the HTML.
List Documents Returns a paginated list of the documents in a mailbox, newest first, filterable by creation date range, name search and one or more processing statuses. The usual way an agent finds what failed or is still waiting for a matching template.
Get Document Retrieves one document with its extracted data, in the same JSON shape Parsio sends to webhooks. Used to collect an asynchronous import, or a synchronous one that outran the request timeout.
Reprocess Document Queues an already imported document to be parsed again. The way to re-run extraction after adding or correcting a template, and the usual fix for a document left in failed status because nothing matched it. Parsing runs in the background.
Skip Documents Marks one or more documents as skipped so Parsio stops processing them and they stop counting towards the parsing quota. The Parsio public API exposes no endpoint for permanently deleting documents, so this is the supported removal path, and agents treat a bulk call as a decision that needs an owner.

Parsed Data

Get Parsed Data Returns the extracted data of a mailbox's documents as a paginated dataset, optionally limited to a creation date range. The bulk export route: a day's invoices into a spreadsheet or a warehouse in one call rather than a fetch per document.

Triggers

1 triggers

Event Triggers

On Document Event Fires when the chosen Parsio event happens in a mailbox. The events are meaningfully different from each other: a document was received, a document was successfully parsed, a document was parsed into a flattened JSON structure, a document failed to parse, or a table field finished extracting its rows. A webhook subscribed to that single event is registered on the mailbox, so the flow runs for every matching document regardless of how it arrived, whether by email, manual upload or API import. The Table Field parameter is required only for the Table Parsed event, and choosing that event is how a flow waits for line items rather than for a header.

Frequently Asked Questions

What can FlowRunner do with Parsio?

FlowRunner agents can run List Mailboxes, Get Mailbox, and List Table Fields in Parsio, plus 8 more actions.

Does connecting Parsio to FlowRunner require OAuth?

No. Parsio connects to FlowRunner with an API key, no OAuth flow required.

Can Parsio trigger a FlowRunner workflow automatically?

Yes. Parsio supports 1 trigger that can start a FlowRunner workflow automatically.

Start building with Parsio

$100 in credits. No card required. Connect in minutes.

Start Building Free Talk to us