DEV Community: vernonroque

The double-counted expense report nobody notices until its too late

vernonroque — Sun, 16 Aug 2026 22:49:29 +0000

A few weeks ago I was testing my own receipt parsing API with a batch of a few hundred receipts pulled from a client's expense folder. Midway through, my upload script crashed on a network timeout. I re-ran it.

Nothing errored. Nothing warned me. I just ended up with roughly 40 receipts counted twice.

That's the failure mode I want to talk about, because it's boring, it's common, and it's the kind of bug that doesn't show up in a demo — it shows up three weeks later when someone's expense total is off by a few hundred dollars and nobody can figure out why.

The failure mode, concretely

If you're building anything that ingests receipts in bulk — an expense tool, a bookkeeping integration, a fintech product pulling from email or cloud storage — there are basically three ways duplicates sneak in:

Retry after a partial failure. A batch upload times out or errors halfway through. You retry the whole batch because you don't know exactly which files made it through. Now some receipts are processed twice.
Overlapping date-range pulls. You're syncing from a source (Gmail, Dropbox, a POS export) on a schedule, and your date windows overlap by a day or two "to be safe." Every receipt in that overlap gets ingested twice.
Multiple people, one folder. Two team members both upload the same photographed receipt because neither knew the other already had it.

None of these are edge cases. They're the normal, expected shape of bulk ingestion once more than one process or person touches the pipeline. And the failure is silent — the API doesn't error, the data doesn't look obviously wrong, it just quietly inflates totals.

How bulk upload works today, and where it stops short

I went and looked at how the major receipt/invoice parsing APIs currently handle bulk submissions, because I wanted to know if this was a solved problem I was about to reinvent badly.

Most of them fall into one of two patterns:

Bundle-and-submit. You package multiple files into a single request — a zip, an array of URLs — and the API processes them as one call. This is fast and simple, but it's really designed for "these pages belong to the same document," not "these are N separate receipts I want deduplicated against each other or against what I've already sent." Veryfi's own documentation is upfront about this: when you zip multiple receipt images together, the system treats them as multiple pages of a single transaction, and explicitly does not check for duplicate line items across them. That's not a criticism — it's an honest scope statement. But it means the bundling mechanism and the deduplication problem are two different things, and only one of them is solved.

True async batch processing. Push a batch into a queue, get results back per file via webhook or polling as they complete. Mindee's API works this way, and it's a solid pattern for throughput. But nothing in that flow checks whether file #47 in this batch is the same receipt as file #12 from last week's batch. The queue processes what you send it. If you send it the same receipt twice, you get two processed receipts back.

In both patterns, deduplication is left as an exercise for the caller. Which means every team building on top of these APIs is quietly re-solving the same problem, usually after they've already shipped and someone found the bug in production.

Where dedup actually needs to live

The reason this is worth building into the API layer rather than leaving it to the client is timing. By the time a duplicate receipt has been through OCR and handed back to your application as two structured JSON objects, you've already paid for two extractions and you're now trying to reconcile two records that might have slightly different OCR noise (a misread cent, a slightly different line-item order) even though they're the same physical receipt. Deduplication after the fact means writing fuzzy-matching logic against imperfect extracted data, which is a worse problem than the one you started with.

The alternative is to catch it at ingestion, before extraction runs twice on the same document. That means the batch endpoint itself needs to know: has this file, or a file materially identical to it, already been processed for this account? If yes, don't burn a second extraction — return the existing record, or flag it, depending on how you want to handle it.

That's the model I built into the bulk endpoint on my own receipt parser: batch upload and duplicate detection aren't two separate concerns bolted together, they're the same code path. When a batch comes in, each file gets checked against what's already been processed before it goes through extraction, not after. A retried batch after a timeout doesn't cost you double, and an overlapping sync window doesn't quietly inflate a total three weeks later.

It's a small, unglamorous feature. But "quietly double-counted expenses" is a small, unglamorous bug — and it's the kind that erodes trust in a financial tool faster than almost anything else, because it doesn't look like a bug. It looks like the numbers are just wrong.

If you're building something that ingests receipts or invoices in bulk, it's worth asking early: what happens when the same file shows up twice? If the honest answer is "I'm not sure," that's worth fixing before it's a support ticket.

--
I'm building ilovesreceipt.com, a receipt parsing API for developers, with batch upload and deduplication as core parts of the same flow. Happy to talk shop about extraction pipelines or dedup strategies in the comments.

Turning a Folder of Receipts into a Clean Spreadsheet — No Manual Entry, No Duplicates

vernonroque — Fri, 24 Jul 2026 01:46:03 +0000

If you've ever had to manually enter receipts into a spreadsheet, you know the drill: retype every line item, double-check you haven't already logged that one, then do the math to convert a foreign currency total into your home currency. It's slow, and it's exactly the kind of task that's easy to mess up when you're doing it by hand.

I built a small app to solve that. It takes a batch of receipt images and turns them into clean, spreadsheet-ready data — automatically.

What it does

The app is a simple front-end on top of a receipt parser API, and it handles three things that usually cause the most friction when processing receipts manually:

Batch upload — drop in a whole folder of receipt images at once instead of processing them one by one.
Deduplication — if the same receipt gets uploaded twice (easy to do when you're going through a big batch), it's automatically caught instead of showing up as a duplicate line item.
Foreign currency conversion — receipts in different currencies get normalized automatically, so you're not manually converting totals before you can compare or total them up.

Getting your data out

Once your receipts are processed, you have two ways to get the data where you need it:

Export to CSV — download a clean file ready to open in any spreadsheet tool.
Copy and paste into Google Sheets — for a faster workflow, the output is formatted so you can paste it directly into a sheet without reformatting.

Setup

There's no complicated onboarding. To start using it:

Paste in your API key
Paste in the API endpoint
Start uploading receipts

That's the entire setup — no configuration files, no separate integration step.

Try it

If you're dealing with a stack of receipts — whether it's expense reports, bookkeeping, or just cleaning up your own records — give it a try:

[Try the app →] https://app.netlify.com/projects/receipt-to-spreadsheet-app/overview
[API docs / free tier signup →] https://ilovesreceipt.com/
[My Youtube video demo →] https://www.youtube.com/watch?v=eVTOC5B4DjA

Let me know what you think, or if there's a feature you'd want to see added.

I compared the four main ways to parse receipts programmatically.

vernonroque — Tue, 21 Jul 2026 01:13:45 +0000

Here's what I found — after actually using all of them, not just reading the docs.

𝗔𝗪𝗦 𝗧𝗲𝘅𝘁𝗿𝗮𝗰𝘁 𝗔𝗻𝗮𝗹𝘆𝘇𝗲𝗘𝘅𝗽𝗲𝗻𝘀𝗲 ✓ Enterprise-grade reliability ✓ Native AWS ecosystem ✗ Requires IAM role + S3 setup (1–2 hours before your first call) ✗ Output is deeply nested key-value blocks — you end up parsing the parser ✗ Accuracy drops on faded thermal paper and non-English receipts ✗ $0.01/page — costs scale linearly, no flat rate

𝗚𝗼𝗼𝗴𝗹𝗲 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁 𝗔𝗜 ✓ Google-grade infrastructure ✓ Better multilingual support than Textract ✗ GCP project + service account + processor selection required ✗ $65 per 1,000 pages for specialized processors ✗ No self-hosting — everything is sent to Google's servers

𝗩𝗲𝗿𝘆𝗳𝗶 ✓ Clean JSON output ✓ Receipt-specific with solid field coverage ✗ Pricing tier isn't indie-project friendly ✗ No self-hosting option

𝗥𝗲𝗰𝗲𝗶𝗽𝘁 𝗣𝗮𝗿𝘀𝗲𝗿 𝗔𝗣𝗜 (what I built) ✓ One HTTP call, structured JSON response, no setup ✓ 50+ fields including line items, payment method, tip ✓ Works on handwritten receipts and non-English documents ✓ Self-hosting available with your own Anthropic key ✓ Free tier — 5 calls/month, no credit card ✗ Not SOC 2 certified — not the right fit for regulated enterprise ✗ No batch processing yet

Bottom line:

→ Need enterprise compliance and you're already on AWS? Use Textract. → Need the fastest path from receipt photo to usable JSON in your app? Try the demo first.

Link to the live demo is in the first comment.

API #DeveloperTools #ReceiptParsing #OCR #AWS #Fintech #IndieDev #BuildInPublic

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.