Forem: vernonroque

How to Automate Expense Reimbursement with n8n and Receipt Parser API

vernonroque — Sun, 17 May 2026 17:16:33 +0000

Target keywords: n8n receipt automation, automate expense reimbursement workflow, n8n HTTP node API
Platform: dev.to (primary) + n8n Community Discord #showcase + Hashnode (cross-post)
Word count target: 1,200–1,500 words
Meta title (60 chars): Automate Expense Reimbursement with n8n + Receipt API
Meta description (155 chars): Build an n8n workflow that parses receipt images, extracts structured data, and routes them for approval — no code required. Step-by-step tutorial.

The API powering this workflow — try it before you build:
👉 ilovesreceipt.com
Upload any receipt and see the structured JSON output in seconds.

What We're Building

An n8n workflow that:

Triggers when a receipt image is submitted (email attachment, Google Drive upload, or webhook)
Parses the receipt using the Receipt Parser API → returns structured JSON
Routes based on amount: auto-approves small expenses, flags large ones for manager review
Logs every expense to a Google Sheet
Notifies the submitter via Slack or email with the parsed details

No code required. Pure n8n nodes.

Prerequisites

n8n instance (cloud or self-hosted — n8n.io)
Receipt Parser API key from ilovesreceipt.com (free tier: 500 calls/month)
Google account (for Sheets logging)
Optional: Slack workspace for notifications

Workflow Overview

[Trigger] → [HTTP Request: Parse Receipt] → [IF: Amount > $50?]
                                                 ├── YES → [Slack: Flag for Review]
                                                 └── NO  → [Google Sheets: Log Expense]
                                                                    ↓
                                               [Gmail/Slack: Notify Submitter]

Step 1: Set Up the Trigger

Choose your entry point based on how employees submit receipts:

Option A — Webhook (most flexible):
Add a Webhook node. Set method to POST. This lets you trigger the workflow from any tool (form, mobile app, Zapier) that can send a webhook.

Option B — Gmail (receipts by email):
Add a Gmail Trigger node. Filter by subject containing "receipt" or "reimbursement". The workflow fires each time a matching email arrives with an attachment.

Option C — Google Drive:
Add a Google Drive Trigger node. Watch a specific folder (e.g., /Receipts/Pending). Fires when any new file is uploaded.

For this tutorial we'll use the Webhook option since it's the most reusable.

Step 2: Read the File

No conversion needed. The Receipt Parser API accepts the raw file directly as multipart/form-data — no base64 encoding required.

If your trigger provides a URL (e.g. a Google Drive file URL), add an HTTP Request node set to GET to download the binary first. If your trigger provides a binary attachment directly (e.g. Gmail attachment), pipe it straight into Step 3.

Step 3: Call the Receipt Parser API

Add an HTTP Request node with these settings:

Field	Value
Method	`POST`
URL	`https://web-production-58295.up.railway.app/api/parse`
Authentication	Header Auth
Header name	`Authorization`
Header value	`Bearer {{ $credentials.receiptParserKey }}`
Body Content Type	Form Data (multipart)
Body field name	`file`
Body field value	(binary data from previous node)

Tip: Store your API key in n8n Credentials as a Generic Credential with Authorization → Bearer YOUR_KEY. This keeps it secure and reusable across workflows. Get your free key at ilovesreceipt.com — 500 calls/month, no credit card required.

After this node runs, you'll have the full parsed JSON available in subsequent nodes as $json.data.merchant.name, $json.data.total, etc.

Step 4: Add Routing Logic (IF Node)

Add an IF node to route based on the expense amount:

Condition:

{{ $json.data.total }} > 50

True branch → flag for manager review (high expense)
False branch → auto-approve and log

You can layer additional conditions:

Category-based routing (meals vs. travel vs. supplies)
Merchant allowlist/blocklist
Employee-specific thresholds

Step 5: Log to Google Sheets

On the False (auto-approved) branch, add a Google Sheets node:

Operation: Append Row
Spreadsheet: your expense log sheet
Sheet: Expenses

Map these columns:

Column	Value
Date	`{{ $json.data.date }}`
Merchant	`{{ $json.data.merchant.name }}`
Total	`{{ $json.data.total }}`
Tax	`{{ $json.data.tax }}`
Tip	`{{ $json.data.tip }}`
Payment	`{{ $json.data.payment_method }}`
Status	`Auto-Approved`
Submitted	`{{ $now }}`

Step 6: Flag for Manager Review (Slack)

On the True (high expense) branch, add a Slack node:

Operation: Send Message
Channel: #expense-approvals
Message:

🧾 *Expense Approval Required*

*Merchant:* {{ $json.data.merchant.name }}
*Amount:* ${{ $json.data.total }}
*Date:* {{ $json.data.date }}
*Payment:* {{ $json.data.payment_method }}

React ✅ to approve or ❌ to reject.

Step 7: Notify the Submitter

On both branches, add a Gmail or Slack node to confirm receipt:

Hi there — your expense was received and parsed successfully.

Merchant: {{ $json.data.merchant.name }}
Date: {{ $json.data.date }}
Total: ${{ $json.data.total }}

{{ $json.data.total > 50 ? "Your expense has been flagged for manager review." : "Your expense has been auto-approved and logged." }}

The Complete Workflow (JSON Import)

You can import this workflow directly into n8n. Copy the JSON below and use File → Import from JSON in n8n:

Download receipt-expense-reimbursement.json

After importing, you'll need to:

Create a Header Auth credential named Receipt Parser API with Authorization: Bearer YOUR_KEY — get your free key at ilovesreceipt.com
Connect your Slack Account credential and update the channel names
Connect your Google Sheets Account credential and replace YOUR_SPREADSHEET_ID with your actual sheet ID

{
  "name": "Receipt Expense Reimbursement",
  "nodes": [
    {
      "id": "1a2b3c4d-0000-0000-0000-000000000000",
      "name": "Setup Instructions",
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [240, 80],
      "parameters": {
        "width": 760,
        "height": 180,
        "content": "## ⚙️ Setup Required Before Running\n1. **Receipt Parser API** — Create a *Header Auth* credential named `Receipt Parser API`. Set header name to `Authorization`, value to `Bearer YOUR_API_KEY`. Get a free key (500 calls/month) at **ilovesreceipt.com**\n2. **Slack Account** — Connect your Slack workspace in Credentials. Update `#expense-approvals` and `#YOUR_CHANNEL` to real channel names.\n3. **Google Sheets** — Connect your Google account in Credentials. Replace `YOUR_SPREADSHEET_ID` with your actual spreadsheet ID (found in the sheet URL)."
      }
    },
    {
      "id": "1a2b3c4d-0001-0000-0000-000000000001",
      "name": "Receipt Submitted",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [240, 320],
      "webhookId": "receipt-parse-webhook-001",
      "parameters": {
        "httpMethod": "POST",
        "path": "receipt-parse",
        "responseMode": "onReceived",
        "options": {}
      }
    },
    {
      "id": "1a2b3c4d-0002-0000-0000-000000000002",
      "name": "Parse Receipt via API",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [460, 320],
      "parameters": {
        "method": "POST",
        "url": "https://web-production-58295.up.railway.app/api/parse",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "contentType": "multipart-form-data",
        "bodyParameters": {
          "parameters": [
            {
              "parameterType": "formBinaryData",
              "name": "file",
              "inputDataFieldName": "data"
            }
          ]
        },
        "options": {}
      },
      "credentials": {
        "httpHeaderAuth": {
          "id": "receipt-parser-api-cred",
          "name": "Receipt Parser API"
        }
      }
    },
    {
      "id": "1a2b3c4d-0003-0000-0000-000000000003",
      "name": "Amount > $50?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2,
      "position": [680, 320],
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "loose"
          },
          "conditions": [
            {
              "id": "amount-check",
              "leftValue": "={{ $json.data.total }}",
              "rightValue": 50,
              "operator": {
                "type": "number",
                "operation": "gt"
              }
            }
          ],
          "combinator": "and"
        }
      }
    },
    {
      "id": "1a2b3c4d-0004-0000-0000-000000000004",
      "name": "Flag for Manager Review",
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [900, 180],
      "parameters": {
        "operation": "postMessage",
        "channel": "#expense-approvals",
        "text": "=🧾 *Expense Approval Required*\n\n*Merchant:* {{ $json.data.merchant.name }}\n*Amount:* ${{ $json.data.total }}\n*Date:* {{ $json.data.date }}\n*Payment:* {{ $json.data.payment_method }}\n\nReact ✅ to approve or ❌ to reject.",
        "otherOptions": {}
      },
      "credentials": {
        "slackApi": {
          "id": "slack-account-cred",
          "name": "Slack Account"
        }
      }
    },
    {
      "id": "1a2b3c4d-0005-0000-0000-000000000005",
      "name": "Log to Google Sheets",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 4,
      "position": [900, 460],
      "parameters": {
        "operation": "appendOrUpdate",
        "documentId": {
          "__rl": true,
          "value": "YOUR_SPREADSHEET_ID",
          "mode": "id"
        },
        "sheetName": {
          "__rl": true,
          "value": "Expenses",
          "mode": "name"
        },
        "columns": {
          "mappingMode": "defineBelow",
          "value": {
            "Date": "={{ $json.data.date }}",
            "Merchant": "={{ $json.data.merchant.name }}",
            "Total": "={{ $json.data.total }}",
            "Tax": "={{ $json.data.tax }}",
            "Tip": "={{ $json.data.tip }}",
            "Payment": "={{ $json.data.payment_method }}",
            "Status": "Auto-Approved",
            "Submitted": "={{ $now }}"
          }
        },
        "options": {}
      },
      "credentials": {
        "googleSheetsOAuth2Api": {
          "id": "google-sheets-account-cred",
          "name": "Google Sheets Account"
        }
      }
    },
    {
      "id": "1a2b3c4d-0006-0000-0000-000000000006",
      "name": "Notify Submitter",
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1120, 320],
      "parameters": {
        "operation": "postMessage",
        "channel": "#YOUR_CHANNEL",
        "text": "=Hi there — your expense was received and parsed successfully.\n\nMerchant: {{ $json.data.merchant.name }}\nDate: {{ $json.data.date }}\nTotal: ${{ $json.data.total }}\n\n{{ $json.data.total > 50 ? \"Your expense has been flagged for manager review.\" : \"Your expense has been auto-approved and logged.\" }}",
        "otherOptions": {}
      },
      "credentials": {
        "slackApi": {
          "id": "slack-account-cred",
          "name": "Slack Account"
        }
      }
    }
  ],
  "connections": {
    "Receipt Submitted": {
      "main": [
        [{ "node": "Parse Receipt via API", "type": "main", "index": 0 }]
      ]
    },
    "Parse Receipt via API": {
      "main": [
        [{ "node": "Amount > $50?", "type": "main", "index": 0 }]
      ]
    },
    "Amount > $50?": {
      "main": [
        [{ "node": "Flag for Manager Review", "type": "main", "index": 0 }],
        [{ "node": "Log to Google Sheets", "type": "main", "index": 0 }]
      ]
    },
    "Flag for Manager Review": {
      "main": [
        [{ "node": "Notify Submitter", "type": "main", "index": 0 }]
      ]
    },
    "Log to Google Sheets": {
      "main": [
        [{ "node": "Notify Submitter", "type": "main", "index": 0 }]
      ]
    }
  },
  "active": false,
  "settings": { "executionOrder": "v1" },
  "meta": { "instanceId": "" }
}

Testing the Workflow

Open the workflow in n8n
Click Execute Workflow with test mode on
Send a POST request to your webhook URL with a receipt image:

curl -X POST https://your-n8n-instance.com/webhook/receipt-parse \
  -F "data=@receipt.jpg"

Check your Google Sheet for the logged row and Slack for any approval notifications.

Going Further

Multi-currency support: The API detects currency — add a conversion step using an exchange rate API
PDF invoices: The API handles PDFs too — great for contractor invoices submitted via email attachment
Airtable instead of Sheets: Swap the Google Sheets node for an Airtable node for richer filtering
Approval loop: Use n8n's Wait node to pause the workflow until a Slack reaction is received

Try the API First

Before building the workflow, see what the parsed JSON looks like for your receipt types:

👉 Live Demo — no signup required

Ready to start building? Get your free API key at ilovesreceipt.com — 500 calls/month, no credit card required.

Built this workflow or have a question about a specific node? Share it in the comments — I'll help debug.

Turn Receipt Images Into Structured JSON With One API Call

vernonroque — Fri, 24 Apr 2026 02:31:48 +0000

Before we dive in — try it right now, no signup required:
👉 [https://ilovesreceipt.com)
Upload any receipt image and see the structured JSON output in seconds.

The Problem With Receipt OCR

Building any kind of expense tracker, reimbursement tool, or bookkeeping automation means you eventually need to extract data from receipts. The standard approaches are painful:

Regex on raw OCR text — works until it doesn't. Fonts, layouts, and languages break it constantly.
AWS Textract / Google Document AI — powerful, but requires IAM setup, SDK configuration, and significant engineering time before you get a single result.
Tesseract — open source and flexible, but returns raw text with no semantic structure. You still need to parse "what is the total?" yourself.

What you actually want is a simple API call that returns structured JSON: merchant name, date, line items, totals, tax, tips, and payment method — without any of the setup overhead.

That's what the Receipt Parser API does. Let's walk through how to use it.

What You'll Build

By the end of this tutorial, you'll have a working script that:

Accepts a receipt image (JPG, PNG, or PDF)
Calls the Receipt Parser API
Returns structured JSON with 50+ fields extracted

Prerequisites

Python 3.7+ or Node.js 14+
Go to https://ilovesreceipt.com and sign up for an api key depending on the tier of your choice
Any receipt image to test with

Get your API key: Subscribe here — the Basic tier is free.

Step 1: Get a Receipt Image

You can use any receipt: grocery store, restaurant, Uber, Amazon, gym — the API handles them all. For this tutorial, grab any receipt photo from your phone.

Not ready to use a real receipt? The live demo includes sample receipts (Restaurant, Grocery, Gym Invoice) you can click to test instantly.

Step 2: Call the API (Python)

import requests
import json

def parse_receipt(image_path: str, api_key: str) -> dict:
    with open(image_path, "rb") as f:
        response = requests.post(
            "https://web-production-58295.up.railway.app/api/parse",
            headers={
                "accept": "application/json",
                "Authorization": f"Bearer {api_key}",
                # Don't set Content-Type — requests sets it automatically
                # for multipart, including the required boundary parameter
            },
            files={"file": f},  # multipart/form-data with field name "file"
        )
    response.raise_for_status()
    return response.json()

result = parse_receipt("receipt.jpg", "YOUR_API_KEY")
print(json.dumps(result, indent=2))

That's it. Five meaningful lines of logic.

Step 3: Call the API (Node.js)

const axios = require("axios");
const fs = require("fs");
const FormData = require("form-data");

async function parseReceipt(imagePath, apiKey) {
  const form = new FormData();
  form.append("file", fs.createReadStream(imagePath));

  const response = await axios.post(
    "https://web-production-58295.up.railway.app/api/parse",
    form,
    {
      headers: {
        "accept": "application/json",
        "Authorization": `Bearer ${apiKey}`,
        ...form.getHeaders(), // sets Content-Type: multipart/form-data with boundary
      },
    }
  );
  return response.data;
}

parseReceipt("receipt.jpg", "YOUR_API_KEY").then((result) =>
  console.log(JSON.stringify(result, null, 2))
);

What the JSON Response Looks Like

Here's actual output from a grocery receipt:

{
  "merchant": {
    "name": "Whole Foods Market",
    "address": "945 Bryant St, San Francisco, CA 94103",
    "phone": "(415) 618-0066"
  },
  "transaction": {
    "date": "2025-03-14",
    "time": "14:32",
    "receipt_number": "00482-391"
  },
  "items": [
    { "description": "Organic Bananas", "quantity": 1, "unit_price": 1.49, "total": 1.49 },
    { "description": "Oat Milk 64oz", "quantity": 2, "unit_price": 5.99, "total": 11.98 },
    { "description": "Sourdough Bread", "quantity": 1, "unit_price": 6.49, "total": 6.49 }
  ],
  "totals": {
    "subtotal": 19.96,
    "tax": 1.40,
    "total": 21.36,
    "tip": null,
    "discount": 0.00
  },
  "payment": {
    "method": "VISA",
    "last_four": "4821",
    "change_due": null
  }
}

And from a restaurant receipt:

{
  "merchant": {
    "name": "The Bird SF",
    "address": "115 New Montgomery St, San Francisco, CA"
  },
  "transaction": {
    "date": "2025-03-15",
    "time": "12:18"
  },
  "items": [
    { "description": "Chicken Sandwich", "quantity": 1, "unit_price": 14.00, "total": 14.00 },
    { "description": "Side Fries", "quantity": 1, "unit_price": 4.00, "total": 4.00 },
    { "description": "Fountain Drink", "quantity": 1, "unit_price": 3.00, "total": 3.00 }
  ],
  "totals": {
    "subtotal": 21.00,
    "tax": 1.89,
    "tip": 4.20,
    "total": 27.09
  },
  "payment": {
    "method": "Mastercard",
    "last_four": "7734"
  }
}

Fields Covered

The API extracts 50+ fields across these categories:

Category	Fields
Merchant	name, address, phone, website, tax ID
Transaction	date, time, receipt number, order number
Line items	description, quantity, unit price, total, modifiers
Totals	subtotal, tax, tip, discount, total, change
Payment	method, card type, last four digits
Currency	detected currency code

Error Handling

from requests.exceptions import HTTPError

try:
    result = parse_receipt("receipt.jpg", "YOUR_API_KEY")
except HTTPError as e:
    if e.response.status_code == 429:
        print("Rate limit hit — upgrade your plan or wait")
    elif e.response.status_code == 422:
        print("Could not parse image — try a clearer photo")
    else:
        raise

What to Build Next

With structured receipt JSON, you can:

Expense tracker: Automatically categorize and log expenses to a spreadsheet or database
Reimbursement tool: Extract line items for approval workflows
Bookkeeping automation: Feed parsed data directly into QuickBooks or Xero
n8n/Zapier workflows: Trigger automations when a receipt is uploaded

Try It Live

Before writing a single line of code, see what the JSON output looks like for your specific use case:

👉 Live Demo — no signup required

Upload a receipt and see the full JSON response in under 5 seconds.

Ready to integrate? Subscribe Here — the Basic tier is free and includes 500 parses/month with no credit card required.

Have questions about a specific receipt type or use case? Drop a comment below.