Skip to content
ParseFlow
← Back to Blog
TutorialJune 22, 20268 min read

Free Invoice Parsing API: Extract Invoice Data Without Paying

How to start parsing invoices programmatically on a free API tier — from your first request to a production-ready integration — with working code in cURL, Python, and JavaScript.

What “Free” Actually Means for an Invoice Parsing API

Most teams searching for a free invoice parsing API want one of two things: a way to evaluate extraction quality before committing to a paid plan, or enough monthly volume to cover a small, low-frequency workload at no cost. A useful free tier should give you a real API key, the same extraction engine paid customers use, and no credit card requirement just to test it.

ParseFlow’s free tier includes 100 documents per month. That is enough to wire up a complete integration, validate accuracy against your own invoices, and run light production workloads. You can review the limits on the pricing page and upgrade only if your volume grows.

What You Need to Get Started

  • A free API key from ParseFlow (no card required)
  • An invoice file in PDF, JPG, or PNG format
  • Any HTTP client — cURL, Python, Node.js, or your language of choice

Step 1: Get a Free API Key

Create an account at parseflow.dev/login. Your key appears in the Dashboard and uses the format dm_live_... for production and dm_test_... for the sandbox. The free tier activates immediately — no upgrade step required.

Step 2: Parse Your First Invoice with cURL

The fastest way to confirm the API works is a single request. This sends an invoice to the extract endpoint and returns parsed data:

curl -X POST https://parseflow.dev/api/v1/extract \
  -H "X-API-Key: dm_live_your_api_key" \
  -F "file=@invoice.pdf" \
  -F "document_type=invoice"

The document_type parameter is optional — omit it and the API auto-detects the document. Setting it explicitly improves accuracy when you already know you are sending invoices.

Step 3: Read the PDF-Invoice-to-JSON Response

The API converts the PDF invoice into a structured JSON object with every field and a confidence score:

{
  "id": "ext_7f3a2b1c-4d5e-6f78-9a0b-cdef12345678",
  "status": "completed",
  "documentType": "invoice",
  "confidence": 0.93,
  "data": {
    "invoiceNumber": "INV-2026-0142",
    "invoiceDate": "2026-06-15",
    "dueDate": "2026-07-15",
    "vendor": { "name": "Acme Corporation", "email": "billing@acme.com" },
    "customer": { "name": "Widget Inc." },
    "lineItems": [
      { "description": "API Integration", "quantity": 1, "unitPrice": 2500.00, "amount": 2500.00 }
    ],
    "subtotal": 2500.00,
    "taxRate": 8.25,
    "taxAmount": 206.25,
    "total": 2706.25,
    "currency": "USD"
  },
  "processingTimeMs": 318
}

The confidencefield (0–1) tells you how reliable the extraction is. Use it to decide which results to auto-process and which to flag for a quick human check.

Step 4: Parse Invoices in Python

A complete Python example with error handling and confidence-based routing:

import requests

API_KEY = "dm_live_your_api_key"

def parse_invoice(file_path):
    """Parse an invoice PDF or image into structured data."""
    with open(file_path, "rb") as f:
        response = requests.post(
            "https://parseflow.dev/api/v1/extract",
            headers={"X-API-Key": API_KEY},
            files={"file": f},
            data={"document_type": "invoice"},
            timeout=30,
        )

    if response.status_code != 200:
        error = response.json()
        raise RuntimeError(f"API error: {error['code']}")

    result = response.json()
    data = result["data"]

    if result["confidence"] < 0.70:
        print("Low confidence — flag for manual review")

    print(f"Invoice {data['invoiceNumber']} — {data['currency']} {data['total']}")
    return result

parse_invoice("invoice.pdf")

Step 5: Parse Invoices in JavaScript / Node.js

The same workflow in Node.js using axios:

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

async function parseInvoice(filePath) {
  const form = new FormData();
  form.append('file', fs.createReadStream(filePath));
  form.append('document_type', 'invoice');

  const { data } = await axios.post(
    'https://parseflow.dev/api/v1/extract',
    form,
    {
      headers: { 'X-API-Key': 'dm_live_your_api_key', ...form.getHeaders() },
      timeout: 30000,
    }
  );

  console.log('Invoice:', data.data.invoiceNumber);
  console.log('Total:', data.data.currency, data.data.total);
  return data;
}

parseInvoice('invoice.pdf').catch(console.error);

Free Tier vs. Paid: When to Upgrade

The free tier is designed for evaluation and light usage. You will want to upgrade when any of these become true:

  • Volume — you consistently exceed 100 documents per month.
  • Batch processing — you need to send many files at once through the batch endpoint instead of one request per invoice.
  • Webhooks and retention — you want asynchronous callbacks and longer result storage for production pipelines.

Until then, the free tier behaves exactly like the paid extraction engine — same accuracy, same JSON schema, same endpoint. Nothing in your code changes when you upgrade.

Handling Scanned Invoices with OCR

Not every invoice is a clean digital PDF. The same endpoint doubles as an invoice OCR API: when you send a scan or photo, it runs optical character recognition before extracting fields. Native PDFs with embedded text are fastest and most accurate (95%+), while scanned images typically land in the 85–93% range for standard layouts. International invoices with VAT, GST, or IVA terminology and different date formats are normalized automatically.

Frequently Asked Questions

Is there a truly free invoice parsing API?

Yes. ParseFlow offers 100 documents per month free with no credit card required. You get a real API key and the same extraction engine as paid plans, so you can build a full integration before deciding whether you need more volume.

How does an invoice data extraction API work?

You POST the invoice file to one endpoint. The API identifies fields like invoice number, vendor, line items, and totals, then returns structured JSON. Native PDFs are read directly; scans go through OCR first.

Can the API convert a PDF invoice to JSON?

Yes. The extract endpoint accepts a PDF and returns a JSON object with the parsed fields plus a confidence score, ready to insert into your database or accounting system.

Does the invoice OCR API support scanned documents?

Yes. Scanned PDFs, JPGs, and PNGs are processed through OCR automatically, with 85–93% field accuracy on standard layouts.

Next Steps

Start parsing invoices for free

Get your free API key and parse up to 100 invoices per month at no cost.

Try the PlaygroundGet Free API Key