From Parse through Classify, Extract, and Instruct: learn the role and settings of each node and you can automate most repetitive document work. Connect them visually in the workflow editor to shape your own pipeline.
Parse
Recognizes any document format as text. The starting point of workflows that begin with uploaded documents.
Classify
Sorts documents into your document types, and can split them with Split mode.
Extract
Pulls only the fields defined in your schema, as structured data. The Mask type creates a PDF with specified values masked.
Instruct
Takes the extracted results and summarizes, transforms, validates, or decides.
Validate
Checks results against rules and gives each case a traffic-light verdict.
Merge
Merges the results of split documents into one.
Match
Finds records whose extracted values match and links them.
Export Β· Import
Saves results to a collection and brings them into another workflow. They aren't in the Add node bar; you add and set them on the Start and End markers of the canvas.
Parse
Parse is the starting point of pipelines that begin with uploaded documents. It recognizes PDFs, images, Office documents, HWP files, and any other format as machine-readable text (HTML and Markdown).
When do you use it?
- In every workflow that starts with uploaded documents: every file goes through Parse, and the downstream nodes take its output as their input. Workflows that start with a collection import bring in results that have already been recognized, so they have no Parse (Export and Import).
- Scanned documents and images are read with OCR; text documents are recognized with their structure analyzed.
- It is especially useful when you need the content of tables, charts, and equations with their structure intact.
Main settings
You choose the Mode directly on the settings screen; OCR, language, and the other options appear when you expand Advanced settings.
| Setting | Options | How to choose |
|---|---|---|
| Mode | Auto / Standard / Enhanced | Auto: picks the best mode per page Β· Standard: clean, well-structured documents Β· Enhanced: complex layouts with many visual elements |
| OCR | Auto (OCR on images only) / Force (Always apply OCR) | Force is recommended. Auto applies OCR only to image pages, so if scans and photos are mixed in, or recognition quality is disappointing, keep it on Force |
| Language | Auto / English / Korean / Japanese / Chinese | If the document language is fixed, naming it is more accurate |
| Nightly | Checkbox | Only if you want to try the latest experimental build first. New features land here first, but stability isn't guaranteed and it can change without notice |
Other advanced options
Options for handling complex documents.
| Setting | When to turn it on |
|---|---|
| Chart recognition | Documents where the numbers inside charts and graphs matter (performance decks and the like). Converts charts into tables. Enabled automatically in Enhanced mode |
| Merge multipage tables | When a table continues across pages (financial reports, settlement sheets); merges them into one table |
| Coordinates | Returns the coordinates of each element. When it is off, document highlighting doesn't work, and it can't be turned off while Extract's location highlight or Mask is using the coordinates (Extract) |
| Pages | Recognizes only some pages of the document. For example: 1,3-5 (page 1 and pages 3 to 5), -10 (from the start through page 10), 10- (from page 10 to the end) |
| Output formats | HTML (check layout) and Text (plain review) are always included. Check Markdown only when you also need it to feed into prompts |
| Image extraction | Figures in the document are always extracted as images. Check this only when you also need other elements, such as tables and charts, as images |
| DPI | Image resolution when recognizing PDFs: 150 (default) / 200 / 300. Raise it for documents with small type |
| JPG quality | Compression quality of the images used for recognition. Choose 75 / 85 / 95 (default); lower it when speed matters on large documents |
Checking the result
Parse results are shown in Preview Β· HTML Β· Text Β· JSON tabs (turn on Markdown in Output formats and a Markdown tab appears too). Elements such as headings, paragraphs, tables, and equations are recognized and tagged by type, and watermarks are removed automatically.
If recognition quality disappoints, try these in order: β check that OCR is set to Force β β‘ switch Mode to Enhanced β β’ raise DPI to 300 β β£ replace the file with a sharper original.
"Parse is the entrance to the workflow. Whatever the document format, it becomes text the downstream nodes can read."
Classify
Classify sorts a mixed pile of documents into document types you define yourself. It is the branching point that lets you apply a different schema and different handling per type.
When do you use it?
- When several kinds of documents arrive mixed together: receipts, contracts, invoices.
- When the same kind of document needs a different schema per vendor.
- When one PDF contains several documents that have to be handled separately (splitting).
You can skip Classify if all your documents are already one type and share a single schema.
Defining document types
Add the names of the documents you want to classify, and write a description for each type. The description is the prompt the AI classifies with, so the clearer and more specific it is, the more accurate the result.
| Field | Example |
|---|---|
| Type name | Domestic receipt, Overseas receipt, Tax invoice |
| Description | A receipt showing a Korean business name and an amount in KRW: spell out whatever is easy to confuse |
- Auto-generate (Beta): Generates document types from your uploaded documents. Select the cases and click Auto-generate. It may take a while.
- Reuse a setup: Document types built in one workflow can be reused in another. Save them as a file with Export as JSON, then Import JSON once in the other workflow and the types, descriptions, and Split settings come across intact. Treat a well-tuned classification setup as a team standard.
Always add an Others type. Without an escape hatch for documents that belong nowhere, the model will force them
into an existing type and cause misclassification. Click the οΌ on the others row previewed with a dashed outline below the document type list, and it is
added right away with the description "Documents that do not belong to the above document classes". If you classify FedEx and UPS invoices,
for example, anything that is neither ends up in Others.
Hierarchical classification: levels 1, 2, and 3
Document types don't have to be a flat list. You can define up to three levels (level 1 β level 2 β level 3) to organize a large number of types systematically.
- Click Add sub-depth on a type row to add types beneath it (three levels maximum). If you went down a level by mistake, use Move up one level to undo it; the tree shows the total number of document types.
- For example:
Invoice(level 1) βCourier invoice(level 2) βUPS shipping invoice(level 3). - The description at every level is also used as a classification prompt, so put broad criteria at the top and specific distinctions further down.
- After a run, the Classification hierarchy tree on the results screen shows which branch each document landed in.
- Design rules: leaf type names must be unique across the whole tree, and every intermediate level needs at least one child. If you only have a handful of document types, one flat level is plenty.
Use Advanced settings when you need to fine-tune how classification behaves. With Custom system prompt you can append instructions that apply to classification as a whole after the existing system prompt. The defaults are enough in most cases, so only open it when classification keeps going wrong.
Fixing classification errors
- Edit only the description of the type that's wrong. Leave the ones that work alone.
- Descriptions are natural language, so refine them iteratively. You can state conditions too, e.g.
FedEx invoices over $10,000. - You can also combine two levels of criteria inside a single Classify node. Splitting into
UPS shipping invoice/UPS other invoicegets you finer granularity without adding another node.
Split: Classify's second mode
Classify runs in two modes: the default mode, which only classifies, and Split mode, which first divides a case (one file or a bundle of files) by document type and then classifies each part. A Classify node with Split turned on gets its own color in the editor. Both take the whole case as input; the difference is the unit of processing.
| Mode | What it does | Suited for |
|---|---|---|
| Classify only | Treats the whole case as one document and assigns it a single type | One document per case |
| Classify with split | Divides one document (file) or a whole document group into several documents, then classifies each | Several documents mixed into one file or group |
Split criteria
| Criterion | Behavior | Suited for |
|---|---|---|
Auto Recommended | Treats the whole input as one, then cuts wherever a new document starts | Most cases. Start here |
| Split by file | Separates a combined file along its original file boundaries | Scanned bundles and other cases where separate files were merged |
| Split by page | Classifies each page while keeping page order | Bulk scans of one-page receipts or forms |
| Split by page + Merge by type | Classifies each page, then groups pages of the same type together | Pages of the same document arriving out of order |
| Custom | Define your own split rule: cut at pages containing a given word, or every N pages | When you have a clear marker like a company name or date |
When splitting by an identifier, test thoroughly. If you split on invoice number, check the results to make sure the model isn't looking at a similar field such as a tracking number instead.
Bringing split documents back together
When the branches created by Split need to be combined back into one flow, add a Merge node. For example, if you want to make one final judgment using the values extracted separately in a contract branch and a receipt branch, gather both branches with Merge and place Instruct after it. Nodes that compare values across different paths (such as Validate) are also connected after Merge has combined the paths.
"Classify is the junction that routes a mixed pile of documents into type-specific paths, so every node after it can behave differently per type."
Extract
Extract pulls specified fields such as names, amounts, and dates out of a document as structured data. The heart of it is schema design: defining what to pull and how.
When do you use it?
- When you need specific fields from a document as structured output such as a table or JSON.
- When the same fields must be extracted consistently from documents that repeat the same layout.
Building a schema
A schema is a list of the fields to extract. Each field has four properties.
| Property | What it is | Example |
|---|---|---|
| Key name | The name of the field to extract (up to 100 bytes) | vendor_name, total_amount |
| Description | The prompt you give the AI (up to 1,000 bytes). The single biggest lever on accuracy | The vendor name at the top of the document |
| Type | The data type of the value | String / Number / Boolean, and so on |
| Array | Check this when values with the same structure repeat | Line items, work history |
For repeating row groups (several fields forming one set, like line items), use Add a table to define a group table.
Reuse your schemas. Save a finished extraction schema as a JSON file with Export schema, and one Import JSON schema in another workflow brings the same settings (key names, descriptions, and types) across. Treat a carefully tuned schema as a team standard.
Writing good descriptions: mini-prompting
The description field is a prompt sent to the model. Use it for these five things.
| Purpose | Example |
|---|---|
| Locate | The vendor name, usually at the top left of the document |
| Include / exclude | Exclude corporate suffixes such as LLC or Inc |
| Format | A dollar amount including two decimal places |
| Disambiguate | Use only the amounts in the line-item detail, not the summary table |
| Normalize | Format dates as YYYY-MM-DD |
Don't skip the table description. Group tables have a top-level description too. Something like
the line items from the detailed billing section, not the summary table tells the model which group of data it is, so it finds the right table.
Mapping schemas to document types
If there is a Classify node upstream, you can apply a different schema to each document type (schema mapping). In the config
panel, drag each document type's connection point to the Extract node that has the right schema (Connect and branch nodes).
For example: Domestic receipt β Extract with the Korean-field schema, Overseas receipt β Extract with the English-field schema.
You can also leave a type (such as "Other") unconnected so it is skipped.
Location highlight and other options
- Location (on by default): Click an extracted value and the matching spot in the original is highlighted in the document viewer, so you can see at a glance where the value came from. This uses Parse's coordinates (Parse). Turning it off gives up the highlight but lets you extract more fields.
- Many rows mode: Improves row extraction accuracy for tables with many rows, at the cost of somewhat slower processing.
- Fallback to Standard: Extracts documents over the 50-page Enhanced limit in Standard mode instead of failing. Available only in Enhanced mode.
- Download results: In the results panel, choose Download all or Download current file.
Don't casually change the schema structure of a production workflow. If extraction results feed a database, adding or removing fields or changing types can break the data pipeline. In production, improve accuracy mainly by editing descriptions, and coordinate structural changes with whoever owns the database.
Mask: creating a PDF with sensitive values masked
Mask is a type of Extract that finds the values of the fields you specify in a document and creates a PDF with them masked. To add it, click the arrow (βΎ) next to Extract in the Add node bar and choose Mask document. You can also switch an existing Extract under Type in its settings. Use it when you need a copy with national ID numbers or contact details masked so you can share it outside the team.
- Fields to mask: Enter the name and description of each field to mask in the Schema table (up to 33 fields). The more specific the description, the more accurately it finds the values to mask. Group tables and nested objects aren't supported.
- Results: Turn on Mask preview at the top right of the document viewer (off by default) to see what was masked, and download the file with the Masked PDF button.
- Mask results can't be used in Match as the Extract to match from.
"Extract lives or dies on schema design. The more precise the key names and descriptions, the more reliably the AI finds the right value. The same goes for the values you mask."
Instruct
Instruct is the node you give natural-language instructions to. It takes the previous node's output and does post-processing such as summarizing, transforming, validating, and deciding.
When do you use it?
| Purpose | Example |
|---|---|
| Normalizing data | $1,000 β 1000; standardize dates to the 2026-01-05 format |
| Comparing against a baseline | Compare extracted contract terms with your standard terms and flag deviations |
| Summarizing | Condense a document or a set of extracted fields into a structured brief |
| Validating | Cross-check business rules. For example: "line item amounts must sum to the invoice total" |
| Deciding / branching | Pick one of a fixed set of decisions such as approve/reject or pass/fail |
Choosing a type
- Instruct only: Returns a free-form text response following your prompt. Right for summaries, translations, and transformations where no fixed decision value is needed.
- Instruct with decisions: Makes a judgment following your prompt and picks one of the options you defined in advance
(for example,
Approve, Reject). Downstream nodes can branch on the decision value. You create the branches the same way as Classify's document type branches (Connect and branch nodes).
Writing the prompt
In the prompt box, type @ to reference an extracted field from an upstream Extract node. With the Instruct with decisions
type, you can also type # to reference the decision values (options) defined in this node.
If you're not sure what to write, click Generate prompts. Enter the output language and any requirements (optional), and it drafts prompt candidates based on your uploaded documents; pick the one you like under Select a prompt. Each candidate comes with the reason it was suggested. You need to upload or select a file before generating prompts.
If the response needs up-to-date outside information, turn on the Web search option. The node then runs a web search before generating its response. You can specify the search query yourself, or leave it blank to have one generated. Responses that used web search show Sources citations so you can check the evidence.
Three ingredients of a good prompt: β state the criteria as numbers and conditions
("please review" β β "reject if the total exceeds 10,000 KRW" β), β‘ reference upstream results with @field_name,
β’ spell out the output format you want.
Where to place it
- After Extract: normalize, validate, and judge the extracted fields (the most common placement)
- After Classify: summarize or route by document type without extracting anything
- Standalone (after Parse): a general-purpose LLM prompt over the whole document
Rather than handing a whole document to a general-purpose LLM, letting Extract handle document understanding and Instruct handle post-processing means the transformation and judgment happen on clean, verified data, which produces markedly more reliable results.
"Instruct is the workflow's decision engine. Pull upstream results in with @ and normalize, validate, and make the final call."
Validate
Validate is the node that checks cases against rules. It automatically tests whether the values extracted by upstream nodes meet conditions you set in advance, and gives each case a traffic-light verdict.
When do you use it?
- When you have criteria that can filter results mechanically before a person goes through them one by one. For example: the total must be greater than 0, the currency must be KRW
- When checking consistency between fields. For example: whether the sum of the line item amounts equals the invoice total
- When you want to flag low-confidence extracted values automatically to set review priorities
Building rules
In the validation rules panel, create rules with Add rule and define the conditions for each.
| Component | What it is |
|---|---|
| What to compare | Pick a result from an upstream node (an Extract field, a Classify result, an Instruct response, a Match field, and so on), and choose whether to compare its Value (the extracted content itself), Confidence (how sure the AI is, 0 to 1), or Length (number of characters or items) |
| Compare against | A value you enter with Direct input, or another field's value with Item reference. A list of numbers can be aggregated with one of Sum, Min, or Max for the comparison |
| Grouping conditions | Add several conditions; when you mix AND and OR, group them like parentheses with a Condition group |
| Requirement | Mark each rule as Required or Optional. This drives the verdict |
Reading the verdict
After a run, each case shows a traffic light.
| Light | Condition |
|---|---|
| π΄ Red | At least one required rule failed |
| π‘ Yellow | One or more optional rules failed |
| π’ Green | All rules passed |
Opening the red cases first and checking which rule caused them cuts review time significantly. To compare values from different split branches (paths), first combine the two paths with a Merge node.
"Validate is the first gate of result review. Leave whatever rules can catch to the machine, and have people start with the red lights."
Merge
Merge is the node that combines the results of documents split by Split into one and passes them to the next node.
When do you use it?
- When you need a case-level overall judgment across split documents. For example, after extracting from a contract, receipt, and invoice separately, you can bundle them as one transaction and have Instruct produce an overall report.
- When cross-checking values from different split branches. Validate can only compare values on the same path, so combine the paths first and then compare (Validate).
- When saving the results of several branches to one collection. Connect Merge before Export and they are saved combined (Export and Import).
- When linking matching records across the extracted values of split branches. Combine them with Merge, then connect Match (Match).
Requirements
Merge works together with a Classify node in Classify with split (Split) mode, because without splitting there are no branches to combine. If Split is off when you click Merge, Studio turns on Split in Classify (or adds a Classify with Split turned on, if there is no Classify) and adds the Merge. Connect the paths you want to merge to the Merge node, and from the node after it, everything is processed as one flow again.
"When Split divides, Merge gathers. Extract per document, then judge per case."
Match
Match is the node that finds records whose extracted values match and links them. It automates checks people used to do by eye, such as matching invoices against purchase orders or extraction results against a reference list.
When do you use it?
- When matching documents uploaded together. For example: link an invoice and a purchase order uploaded together as one case with Upload as combined by their number, then compare the amounts
- When matching against earlier run results. For example: compare this month's extraction results with last month's results stored in a collection
- When matching against a reference list. For example: check extracted vendor names against an uploaded vendor list (a table file)
Where it connects: Match can only come right after an Extract (including after a Merge that combines Extracts). If you add Match from the node bar and there is no Extract before it, an Extract is added along with it.
Setting it up
Match from
Choose the Extract that serves as the basis of the comparison. You need to choose it before you can pick what to match it to. You can't choose a Mask-type Extract here.
Match to
Choose what to compare against. Use Add another target to set up several targets, and give each one a Result name. Matched records are added to the result under this name; you can keep the default.
- From this workflow: Compare documents uploaded together, such as an invoice and a purchase order. Whether it's one file containing several documents or a case bundled with Upload as combined, β turn on Split in Classify, β‘ add an Extract to each path, β’ join them with Merge, and β£ add Match. The settings screen shows the same guide.
- From collections: Compare with results that an earlier run saved with Export (Export and Import). Only collections of Extract results can be chosen. If what you want is to take collection results as input and keep processing them, start with a collection Import instead of Match.
- Upload table file: Compare with a table file (a reference list such as a vendor list) uploaded to the Collections page. You can also upload a new file right from the Match settings.
Match type and fields
Document fields compares one value per document, like an invoice number, and links documents with the same value. Table rows compares tables row by row, like line items, and links rows with the same values even if they're in a different order. Turn on at least one, and choose the From field and To field (for tables, the From column and To column).
How to compare
For each match type you turn on, choose Exact match or Similar text, which tolerates typos and formatting differences. In the advanced settings you can set Max links per record (1β100; 10 if left empty), and for Similar text you can turn on Minimum similarity and set it between 0.3 and 1 (higher is stricter).
Reading the results
- On the results screen you can compare the From value and Matched value side by side.
- For a Match placed after Merge, check the results on the document of the Extract you chose in Match from (step 1). In this setup you can connect only Instruct or Validate after Match to judge or check the comparison, and you can't Export the match results to a collection.
"Match connects scattered records through a shared value. Choose the right From field and the checks you used to do by eye become automatic."
Export and Import
Export saves run results to a collection (a searchable data store), and Import brings results saved in a collection into another workflow to keep processing them. Both are set on the Start and End markers at either end of the canvas, and they let you build chains of workflows that pass data to one another.
Export: saving results to a collection
- How to add it: On the canvas, click the End marker shown at the end of each flow and choose Export as the ending. That creates an Export. Choose End here to finish there without exporting to a collection.
- Location: Choose New Collection or Existing Collection. A new collection is created the first time results are saved; choosing an existing one adds the results to it.
- Saved results: The results of the connected path are saved as rows. A new collection can take several connected paths, each saved separately, but an existing collection can hold only one result. To save them combined, connect a Merge before it.
- Collection name: Name the new collection (up to 100 bytes). If you leave it blank, the node name is used.
- Rules: One Export saves to only one collection, and two Exports can't use the same collection. The results of a Match connected after Merge can't be saved to a collection (Match).
Import: bringing in collection results
- How to add it: Click the Start marker at the very beginning of the canvas and change the input method from Manual input (starting from uploaded files) to Collection import. Search for and select a collection under Import collection results; it shows the number of runs and files. Changing the input method disconnects the nodes that were connected after Parse, so reconnect only the ones you need.
- What you can import: Only collections created from workflow run results. Collections created from spreadsheet files (CSV, Excel) can't be imported.
- Continued processing: The downstream nodes (Instruct aggregation, judgment, and so on) take the imported results as input and keep going.
Using them together: A receipt extraction workflow Exports its results to a collection every day, and a month-end settlement workflow Imports that collection to build an aggregate report. You don't have to put extraction and aggregation in one workflow.
"Build up with Export, chain with Import. With a collection in between, workflows use each other's results as ingredients."
Not every workflow needs every node. See Use cases for how nodes are assembled into real work.