Agentic Invoice Extraction

Drop an invoice into a Google Drive folder and let an agent do the rest: OCR the page, extract every field into clean JSON, self-score its own confidence, auto-ship the high-confidence ones to Airtable, and pause the doubtful ones for a human reviewer. This guide builds the full 16-node pipeline — trigger, OCR, extraction agent, two confidence gates, a Human-in-the-Loop review loop, and dual exit paths into Airtable and Drive.

To start, create a new Event workflow (e.g. Agentic_Invoice_Extraction) in the DEV environment from Design → Flow Designer → Workflow Canvas, then follow the steps below.

What you'll build

Architecture at a glance

The pipeline has two halves that meet at a confidence gate:

1. Ingest & extract — a Google Drive App Event Trigger fires on drive:file:created, an HTTP Request reads the file bytes, a second HTTP Request sends them to Google Vision for DOCUMENT_TEXT_DETECTION, and the Invoice Extraction Agent (a ReAct agent on GPT-4o) parses the OCR text into a JSON invoice with a self-scored confidence_score (0–100).
2. Route & ship — a Router branches on confidence_score >= 90:
   • Branch A (≥ 90%) — a Validate & Serializer Agent reformats the JSON and writes it to Airtable, then an HTTP Request archives the file in the Success Drive folder.
   • Branch B (< 90%) — a Human In The Loop node pauses for a reviewer, who either submits feedback (feeding a second ReExtraction Agent → a second Router at >= 85) or flips a move_into_exception flag to drop the file straight into the Exception folder.

What you'll learn

• Wire a Google Drive App Event Trigger and chain two HTTP Request nodes (Drive read → Vision OCR).
• Build a ReAct agent that extracts invoice JSON and scores its own confidence in one pass.
• Use a Router to branch on that confidence, and a second Router to gate the re-extracted result.
• Insert a Human In The Loop review step with feedback and an exception-override flag.
• Ship structured records to Airtable and archive source files to Drive folders.

Before you begin

• A FlowGenX account with access to Design → Flow Designer → Workflow Canvas.
• A Google Drive connector authorized (with the drive / drive.file scope) — you'll need three folders: a watched inbox, a Success folder, and an Exception folder.
• A Google Vision connector authorized (API key credential).
• An Airtable connector authorized, plus a base and table to receive invoice records.
• An LLM provider API key (this guide uses OpenAI gpt-4o for its JSON mode + 128k context).

Step 1 — App Event Trigger (Google Drive)

Goal: fire the workflow whenever a new file lands in your watched Drive folder. (~3 min)

1. Drag an App Event Trigger (node type: AppEventTrigger) onto the canvas.
2. Connect the Google Drive app and select the drive:file:created event.
3. Set the folder filter to your watched inbox folder.
4. Confirm the connection shows connection_status: connected, then click Apply.

Step 2 — HTTP Request: read file bytes

Goal: pull the raw file bytes so Vision can OCR them. (~3 min)

1. Drag an HTTP Request node (node type: HTTPRequest) after the trigger and connect the edge.
2. Switch to the App Connector tab and pick Google Drive → "Read file data as bytes."
3. Map the file_id path variable to the trigger event: {{ ["<App Event Trigger node id>"].output.event_data.file_id }}.
4. Click Apply.

Step 3 — HTTP Request: Google Vision OCR

Goal: convert the bytes into machine-readable text. (~3 min)

1. Drag a second HTTP Request node after Step 02 and connect the edge.
2. In the App Connector tab, pick Google Vision → "Detect document text from base64-encoded files" (POST /api/v1/google-vision/detect-document-text-raw), which runs DOCUMENT_TEXT_DETECTION.
3. Feed it the bytes from Step 02 and pick your GoogleVision api_key credential.
4. Click Apply.

Step 4 — ReAct Agent: Invoice Extraction Agent

Goal: extract the invoice into JSON and self-score confidence. (~8 min)

1. Drag a ReAct Reasoning & Acting Agent (node type: ReactAgent) after Step 03 and connect the edge. Rename it Invoice Extraction Agent.
2. In the model picker, choose Open Ai 4o (gpt-4o) — it supports JSON mode and a 128k context, both needed for full-page invoices.
3. Paste the system prompt below into the Prompt field.
4. Add a single input field invoice_text (string) with expression {{ ["<Vision OCR node id>"].output.text }}.
5. Declare the output schema: invoice (object), confidence_score (number 0–100), validation_summary (object).
6. Click Apply.

# Invoice Extraction & Validation Agent — System Prompt
ROLE: You are an Invoice Extraction & Validation Agent. Receive raw invoice
text (OCR output, copy-pasted text, or structured input) and return only a
single valid JSON object. No markdown, code fences, or commentary.

PIPELINE:
1. EXTRACT — parse the raw text into the invoice schema. Normalize whitespace;
   strip currency symbols; parse dates to YYYY-MM-DD; join multi-line addresses
   into one comma-separated string; compute line_total = quantity * unit_price
   if missing; use null for any field you cannot find. Ignore PDF watermarks
   and generator footers.
2. VALIDATE — run 10 checks (V1..V10). CRITICAL: invoice_number, invoice_date,
   total > 0. HIGH: sum(line_total) == total ±0.01, each line item has
   description / quantity > 0 / unit_price >= 0, line_total == quantity *
   unit_price ±0.01. MEDIUM: billing_name or billing_company present.
   LOW: billing_email pattern, shipping_address present, no duplicate line items.
3. SCORE — start at 100. Subtract per missing field (invoice_number -12,
   invoice_date -10, total -12, line_items -18, billing_name -7,
   billing_company -6, billing_address -6, billing_email -5, shipping_name -5,
   shipping_address -5, subtotal -5, notes -3, issuer -3, contact_info -3).
   Subtract per issue (CRITICAL -10, HIGH -5, MEDIUM -2, LOW -1). Floor at 0.
4. STATUS — PASS if score >= 85 AND zero CRITICAL/HIGH issues. WARN if
   score >= 50 OR only MEDIUM/LOW issues. FAIL otherwise.
5. OUTPUT — one JSON object: { confidence_score, validation_summary, invoice }.
   Nothing else.

RULES: JSON only. Never fabricate. Run all checks before scoring. Be
conservative — when in doubt, lower the score and add an issue. If input is not
parseable as an invoice, return { confidence_score: 0, status: "FAIL",
issue: "Input does not appear to contain invoice data" }.

Step 5 — Router: Confidence ≥ 90%?

Goal: branch the workflow on the agent's self-scored confidence. (~3 min)

1. Drag a Router (node type: Router) after Step 04 and connect the edge. Rename it greater than 90% confidence score?.
2. Set Routing Strategy = expression_based, Matching Strategy = first_matching, drop_unmatched = false, fallback_route = fallback.
3. Add one expression: routing_path = greter, expr_type = JEXL, expr = confidence_score >= 90.
4. Map the input field confidence_score from the Invoice Extraction Agent output.
5. Click Apply.

JEXL expression   : confidence_score >= 90
Routing path      : greter        (true branch, ≥ 90%)
Fallback route    : fallback      (false branch, < 90%)
drop_unmatched    : false
matching_strategy : first_matching

Branch A — High confidence (≥ 90%): auto-ship

The happy path: the agent was confident enough, so a serializer agent reformats the JSON for Airtable, the Create multiple records tool ships it, and the source file is archived in the Success folder.

Step 6 — Validate & Serializer Agent + Airtable tool

Goal: reformat the invoice JSON and insert it into Airtable. (~6 min)

1. From the Router's greter branch, drag a ReAct Reasoning & Acting Agent and connect the edge. Rename it Validate & Serializer Agent. The config panel is identical to Step 4 (see the figure there).
2. Use the same Open Ai 4o model as Step 04.
3. Paste the serializer prompt below.
4. Map the input field invoice (object) from the Invoice Extraction Agent.
5. Declare the output schema: records (object), airtable_success (boolean), airtable_record_id (string), details (string).
6. Open the agent's Tools panel and add the Airtable tool "Create multiple records" — this connects the agent → tool via a child handle (diamond-bottom on the agent, diamond-top on the tool).
7. In the tool config, fill base_id, table_id, and typecast = true. Replace the recipe's defaults (base_id app0qDnPxBXkYq2Pl, table_id tbly4dLxpgdsDb91G) with your own.
8. Click Apply.

As a specialized REACT Agent, your task is to convert incoming invoice data
into the Airtable batch-create format and synchronize it, even if some fields
fail validation.

1. THOUGHT — Analyze the invoice (input field: invoice). Extract the canonical
   fields (tax, notes, total, issuer, currency, discount, subtotal, line_items,
   billing_name, invoice_date, billing_email, contact_email, contact_phone,
   shipping_name, invoice_number, billing_address, billing_company,
   shipping_address). Mark any missing/invalid field but continue.
2. ACTION — Reformat into: { "records": [ { "fields": { ... } } ] }
   Invoke the "Create multiple records" tool with:
     base_id  : <your base id>
     table_id : <your table id>
     typecast : true
     batch    : max 10 records per request
3. OBSERVATION — Read the tool's response.
4. FINAL RESPONSE — A single JSON object:
   {
     "airtable_success": true | false,
     "airtable_record_id": "rec...",
     "details": "Successfully created N records.  <validation notes>"
   }

Step 7 — HTTP Request: move file to Success

Goal: archive the processed file in the Success Drive folder. (~3 min)

1. After the Validate & Serializer Agent, drag an HTTP Request node and connect the edge.
2. In the App Connector tab, pick Google Drive → "Move a file to a different folder" (same picker as Step 2).
3. The connector auto-fills method = PATCH, path = /api/v1/googledrive/files/{file_id}/move, header Content-Type: application/json.
4. Set the body destination_folder_id to your SUCCESS folder ID (the recipe ships 107rNxawb6uLKiwOarli8FZL8-N44Jdnl as an example).
5. Map the file_id path variable to the trigger event (same expression as Step 2).
6. Click Apply.

PATCH /api/v1/googledrive/files/{file_id}/move
Content-Type: application/json
Body: { "destination_folder_id": "<SUCCESS_FOLDER_ID>", "new_name": null }
Path var: file_id = {{ ["<App Event Trigger node id>"].output.event_data.file_id }}

Branch B — Low confidence (< 90%): Human In The Loop

This branch pauses the workflow so a reviewer can look at the source invoice and the agent's draft JSON. The reviewer either submits feedback (which feeds a second extraction pass) or flips move_into_exception to drop the file directly into Exception without re-extracting.

Step 8 — Human In The Loop + "Move to exception?" Router

Goal: pause for human input, then route on the reviewer's decision. (~6 min)

1. From the Router's fallback branch (Step 05), drag a Human In The Loop node (node type: HumanInTheLoop) and connect the edge.
2. Set assignment_type = email and pick a notification recipient.
3. Configure the reviewer form to collect: feedback (string, multi-line) and move_into_exception (boolean checkbox).
4. In the context payload to the reviewer, pass invoice (the agent's JSON draft), confidence_score, and the source file's Drive preview link.
5. Set timeout_hours = 23 with reminder_count = 2 and an escalation timeout of 48 hours. Click Apply.
6. Drag a Router after the HITL and connect the edge. Rename it move to exception folder?.
7. Map the inputs feedback and move_into_exception from the HITL output.
8. Add the JEXL expression move_into_exception == true with routing_path = yes, fallback_route = no. Click Apply.

Step 9 — HTTP Request: move to Exception (yes branch)

Goal: archive untouched files when the reviewer flagged them as exceptions. (~2 min)

1. From the yes branch of the "move to exception folder?" Router, drag an HTTP Request node and connect the edge.
2. Same Google Drive "Move a file to a different folder" operation as Step 7 (see Step 2).
3. Set destination_folder_id to your EXCEPTION folder ID (the recipe ships 18YvI-7eKhQBxGAzCGV7oclDlf2iIj3K3 as an example).
4. Map file_id the same way as Step 7. Click Apply.

Step 10 — ReAct Agent: Invoice ReExtraction Agent (no branch)

Goal: re-extract with the reviewer's feedback merged in. (~5 min)

1. From the no branch of the "move to exception folder?" Router, drag a ReAct Reasoning & Acting Agent and connect the edge. Rename it Invoice ReExtraction Agent. Same model and panel as Step 4.
2. Paste the re-extraction prompt below.
3. Add two input fields: invoice_text (string) bound to {{ ["<Vision OCR node id>"].output.text }} (the original OCR text), and human_feedback (string) bound to {{ ["<HITL node id>"].output.feedback }}.
4. Declare the output schema: invoice (object), confidence_score (number), validation_summary (object) — same shape as Step 4.
5. Click Apply.

# Improved Invoice Extraction & Validation Agent — System Prompt
ROLE: Same as the Invoice Extraction Agent (Step 04), but you also receive
human_feedback. Re-extract the invoice JSON and incorporate the feedback
faithfully. Return one JSON object — no markdown, no commentary.

PIPELINE:
1. EXTRACT — same rules as Step 04 (normalize whitespace, parse currency/dates,
   join addresses, compute missing line_total, null for missing, ignore OCR noise).
2. INCORPORATE FEEDBACK — apply the reviewer's corrections to the extracted
   fields. Don't alter fundamental data that the reviewer didn't touch.
3. VALIDATE — same 10 checks (V1..V10) and the same severities.
4. SCORE — same penalty table. Floor at 0.
5. STATUS — PASS / WARN / FAIL same as Step 04.
6. OUTPUT — one JSON object: { confidence_score, validation_summary, invoice }.

RULES: JSON only. Never fabricate. Run all checks before scoring. Be
conservative — a clear correction from the reviewer can raise the score; a
comment like "I'm not sure either" should not.

Step 11 — Router: Confidence ≥ 85%? (re-extracted)

Goal: decide whether the re-extracted record can ship. (~2 min)

1. Drag a Router after the ReExtraction Agent and connect the edge. Rename it greater than 85% confidence score?. Same panel as Step 5.
2. Add the JEXL expression confidence_score >= 85 with routing_path = greter, fallback_route = fallback.
3. Map the input field confidence_score from the ReExtraction Agent. Click Apply.

Step 12 — Path B1: reviewed & shipped (re-extracted ≥ 85%)

Goal: ship the human-reviewed record and archive the file. (~4 min)

1. From the greter branch of the second Router, drag a ReAct Reasoning & Acting Agent and connect the edge. Rename it Validate & Serializer Agent 2. Configure it identically to Step 6 — same prompt, same Airtable Create multiple records tool, same base_id / table_id / typecast. The only difference: it operates on the re-extracted invoice (input from Step 10's agent, not Step 04's).
2. Drag an HTTP Request node after the agent. Same Google Drive "Move a file to a different folder" operation as Step 7. Use the SUCCESS folder ID.
3. Click Apply on both nodes.

Step 13 — Path B2: Exception (re-extracted < 85%)

Goal: route untrusted records out of the auto pipeline. (~2 min)

1. From the fallback branch of the second Router, drag an HTTP Request node and connect the edge.
2. Same Drive "Move a file to a different folder" operation as Step 9 — only the source branch differs. Use the EXCEPTION folder ID. Click Apply.

Step 14 — Save, publish, and test

Goal: persist your work, promote it, and run sample invoices through. (~5 min)

1. Click Save (bottom-left of the canvas).
2. Click Republish (or Publish on first publish) and confirm the publish target.
3. Upload a clean test invoice to your watched Drive folder. Watch the trace highlight Branch A: Invoice Extraction Agent → Router (greter, ≥ 90%) → Validate & Serializer Agent → Create multiple records → Drive Move (Success).
4. Upload a low-quality scan or handwritten note. Confirm the run pauses at the HITL node and an email reaches the reviewer.
5. As the reviewer, submit feedback (without ticking move_into_exception). Confirm the workflow resumes through the ReExtraction Agent → second Router → Path B1 (or B2 if the re-extracted score is still low).
6. Repeat with move_into_exception = true. Confirm the file jumps straight to the Exception folder without re-extracting.

Node reference

Every node in the recipe, with the canvas label and what it wires up.

You're done — what's next

You've built, configured, published, and tested a 16-node agentic invoice extraction pipeline with OCR, self-scored confidence, Human-in-the-Loop validation, and dual exit paths into Airtable and Drive. Keep going:

• Introduction to Agents — Deep, React, Supervisor, and Swarm patterns.
• CRM Enrichment and Lead Scoring — another multi-agent pipeline with tool-calling.
• Traceability — full run observability for pipelines like this one.

Troubleshooting

Glossary

• App Event Trigger — a trigger node that fires from an external app webhook. Here: Google Drive's drive:file:created event.
• HTTP Request (with App Connector op) — a generic HTTP node bound to a specific operation on a registered connector (Drive "Read file as bytes", Vision "Detect document text", Drive "Move a file"). The connector contributes auth, schema, and OpenAPI spec — you don't write raw URLs.
• ReAct Reasoning & Acting Agent — an LLM-backed node that reasons in steps and emits structured output. This recipe uses four: Invoice Extraction, Validate & Serializer (×2), and Invoice ReExtraction.
• Router (expression_based) — a node that branches on a JEXL expression over its inputs. Used three times: confidence_score >= 90, move_into_exception == true, confidence_score >= 85.
• Human In The Loop — a pause node that surfaces the workflow state to a reviewer by email and resumes once they submit the configured fields (here: feedback + move_into_exception).
• Generic Tool (Create multiple records) — an Airtable connector tool attached to a ReAct agent via the diamond child handle; batch-inserts up to 10 records per call with optional typecast.
• confidence_score — a 0–100 number emitted by the extraction agents, driven by a deterministic penalty table over missing fields and validation issues (see the Step 4 prompt).
• validation_summary — an object emitted alongside the invoice JSON, containing an issues[] array (CRITICAL / HIGH / MEDIUM / LOW).