Papaya: Pay Any Bill API integration & OpenFinance

OpenFinance · OpenData · Bill OCR · Webhook events

Connect Papaya: Pay Any Bill to your accounting, billing and reconciliation stack

Papaya turns paper bills into machine-readable, payable records using computer vision. Our integration layer mirrors that capability programmatically: you upload a bill image, receive structured fields (amount, due date, account number, biller name), trigger a payment from a stored funding source, and reconcile the outcome via webhooks. Everything is wrapped behind one OpenFinance-style endpoint set and delivered as runnable source code or a hosted API.

OCR bill extraction (Extract API) — Submit a JPEG of any paper or PDF bill and get back full text plus key/value pairs including biller name, account number, balance due and due date. Useful for AP automation and patient billing intake.

BillPay REST endpoints — Create, schedule, cancel and query bills against the public Papaya BillPay API. Supports recurring schedules, partial payments and multiple payment methods (ACH, card, FSA/HSA).

Real-time webhook fan-out — Subscribe to extraction-completed, payment-sent, payment-settled and exception events; we re-deliver them to your queue with HMAC signing and replay protection.

Statement & reconciliation exports — Pull a normalized history of bills, payments and clearing dates as JSON, CSV or Excel for accounting tools such as QuickBooks, Xero, NetSuite or Sage Intacct.

Data available for integration

Papaya holds three valuable layers of data that our integration surfaces in a normalized OpenFinance shape: the raw and parsed bill, the payment instruction and result, and the recurring relationship with each biller. The table below maps each data type to its source, granularity and a typical downstream use.

Data type	Source (screen/feature)	Granularity	Typical use
Extracted bill fields	Snap-a-bill camera intake / Extract API	Per bill image: biller, amount, account number, due date, line items	AP automation, patient statement intake, invoice ingestion for ERP
Bill objects	"Bills" tab / BillPay `/bills`	Per bill: status, balance due, schedule, payment method binding	Cash-flow forecasting, dunning workflows, late-fee prevention
Payment events	Payment lifecycle / webhooks	Per event: created, sent, settled, failed, refunded	Reconciliation against bank ledger, exception handling, SLA reporting
Funding methods	Wallet / payment method screen	Per token: rail (ACH, card, FSA/HSA), masked PAN, expiry, default flag	Risk scoring, payment routing, FSA-eligibility checks
Biller relationships	"Billers" / recurring schedules	Per biller: category, recurrence cadence, average amount	Subscription analytics, vertical benchmarks, cancellation outreach
Receipt artifacts	Confirmation screen / extract output	Per payment: PDF receipt, hashed image reference, audit trail	Tax filing, expense management (FSA/HSA substantiation), audit evidence

Typical integration scenarios

The four scenarios below are the ones clients ask for most often when they want Papaya capabilities behind their own product, internal portal or back-office workflow.

1. Patient billing intake for a healthcare RCM platform

A revenue-cycle management vendor accepts paper EOBs and provider invoices uploaded by patients. Each upload hits our /extract proxy, which forwards to the Papaya Extract API. The webhook returns structured fields (provider, account number, balance due) and we hand the patient a one-tap "Pay with HSA" button bound to the BillPay create_bill + schedule_payment calls. Maps to OpenFinance because the patient retains custody of the funding source while consenting to a single charge.

2. Property management rent and utility automation

A multi-family operator ingests utility bills delivered to leased units. Our pipeline OCRs each bill, deduplicates against a unit-level ledger and schedules ACH payments on the cycle date. Webhook events for payment.settled close the AP entry in NetSuite. The result is a unified rent + utilities + parking dataset that previously required logging into a dozen biller portals.

3. SMB AP co-pilot integrated with QuickBooks

An accounting add-on lets a small business email a bill to a unique address. We strip the attachment, send it through Extract, generate a draft bill in QuickBooks and queue a Papaya payment. When Papaya marks the payment as settled we mark the QuickBooks bill paid and write the receipt PDF to the document store. Eliminates manual data entry and provides a 24-hour clearing SLA on most rails.

4. Consumer finance dashboard with cross-app statement export

A budgeting app wants a unified "bills paid" feed across Papaya, doxo and direct biller portals. We expose a normalized /statements endpoint that returns Papaya bills, payments and biller categories in the same shape as our other connectors, so the front-end only consumes one data model. This is a classic OpenData use case: structured access to data the user already owns.

5. Compliance and audit log feed for regulated tenants

For HIPAA- or SOC 2-regulated tenants we expose an append-only /audit stream with hashed bill image references, consent records, payment outcomes and operator IDs. Used to satisfy CFPB Regulation E inquiries, HIPAA access logs and internal SOX controls.

Technical implementation

1. Submit a bill image to OCR

POST /api/v1/papaya/extract
Content-Type: multipart/form-data
Authorization: Bearer <ACCESS_TOKEN>

file: bill.jpg
callback_url: https://yourapp.example.com/hooks/papaya/extract

// 202 Accepted
{
  "extract_id": "ext_3f9c8b21",
  "status": "queued",
  "received_at": "2026-05-10T14:02:11Z"
}

2. Webhook delivery — extraction complete

POST https://yourapp.example.com/hooks/papaya/extract
X-Papaya-Signature: t=1715349731,v1=ad6f...
Content-Type: application/json

{
  "event": "extract.completed",
  "extract_id": "ext_3f9c8b21",
  "fields": {
    "biller_name": "Cedars-Sinai Medical",
    "account_number": "123-45-678",
    "amount_due": "248.37",
    "currency": "USD",
    "due_date": "2026-05-28"
  },
  "raw_text": "Cedars-Sinai... Balance due 248.37..."
}

3. Create and schedule a payment

POST /api/v1/papaya/bills
Content-Type: application/json
Authorization: Bearer <ACCESS_TOKEN>

{
  "biller_name": "Cedars-Sinai Medical",
  "account_number": "123-45-678",
  "amount": "248.37",
  "currency": "USD",
  "due_date": "2026-05-28",
  "funding_method_id": "fm_hsa_9821",
  "schedule": "immediate"
}

// 201 Created
{
  "bill_id": "bill_a72e",
  "payment_id": "pay_71fd",
  "status": "submitted",
  "estimated_settlement": "2026-05-11T18:00:00Z"
}

4. Pull a statement export

GET /api/v1/papaya/statements?from=2026-04-01&to=2026-04-30&format=csv
Authorization: Bearer <ACCESS_TOKEN>

// 200 OK
bill_id,biller,amount,currency,paid_at,settled_at,funding,status
bill_91a,ConEd,82.40,USD,2026-04-03,2026-04-04,ach_3311,settled
bill_92b,Sprint,65.00,USD,2026-04-05,2026-04-06,card_2289,settled
...

Compliance & privacy

Bill payments touch three regulatory regimes at once in the United States: card data (PCI DSS), consumer electronic payments (the CFPB Regulation E framework for EFTs), and protected health information when medical bills are processed (HIPAA). We design every Papaya integration to respect all three. Card numbers never touch your server; they live as tokenized funding methods. Healthcare workflows follow data-minimization with explicit consent records and a Business Associate Agreement when PHI is in scope. For consumer-finance products we mirror Regulation E disclosure timing and dispute windows.

For European or UK tenants who want to combine Papaya bill data with bank account aggregation, we layer a PSD2-style consent dashboard on top so end users can revoke access at any time. Our default retention policy is 12 months for raw bill images and 7 years for payment records, configurable per tenant.

Typical modules we ship

OAuth + token refresh wrapper around Papaya BillPay credentials
Multipart upload service with image pre-processing (deskew, denoise)
Webhook receiver with HMAC verification and idempotent replay
Bill / payment / funding-method data models in Postgres
Reconciliation worker that joins Papaya events to bank statements
Tenant-scoped audit log feed (JSON Lines, optional S3 sink)

Data flow / architecture

A typical Papaya integration follows a four-stage pipeline:

Client capture — Mobile or web client uploads a bill JPEG or PDF, plus the chosen funding method ID.
Ingestion / API gateway — Our wrapper authenticates, deduplicates, calls Papaya Extract and BillPay, and signs an internal trace ID into every downstream call.
Storage — Structured bill, payment and event records land in Postgres; raw images go to encrypted object storage (S3, GCS, or Azure Blob) with per-tenant KMS keys.
Analytics & output — A reconciliation worker emits CSV/JSON exports and webhook fan-out to your accounting tool (QuickBooks, NetSuite, Xero) and your data warehouse (BigQuery, Snowflake, Redshift).

Market positioning & user profile

Papaya is a US-headquartered consumer fintech founded in 2016 and based in West Hollywood, California. In December 2021 it raised a $50M Series B led by Bessemer Venture Partners (total funding ~$65M) and the company was named PayAwards "Most Innovative Technology" winner — the snap-a-bill OCR pipeline was co-developed with computer-vision veteran Jason Meltzer, formerly of iRobot Roomba. The user base skews toward US consumers paying medical, dental, rent, utility, parking and DMV bills, plus small businesses and pet/childcare operators that issue paper invoices. The mobile-first audience uses both Android and iOS, with most payment volume concentrated in the United States across all 50 states. Recent product evolution has emphasized FSA/HSA card support and a developer-facing BillPay + Extract API that opens the same OCR-and-pay engine to third parties — the foundation our integration layer builds on.

Screenshots

Tap any thumbnail to view the full image. Sourced from the official Google Play listing.

Similar apps & integration landscape

Teams who integrate Papaya often integrate adjacent bill-payment or finance apps in the same workflow. The list below is a non-ranked map of the broader ecosystem so you can plan a unified data model from day one.

doxo — Pay-any-biller marketplace covering 120,000+ US billers; users who work with both doxo and Papaya often need a single normalized payment-history feed.
Prism Money — Bill tracking and payment with calendar view; common pairing for cash-flow dashboards that overlay due dates from multiple sources.
BillTracker — Lightweight reminder app focused on due-date hygiene; integration value comes from cross-feeding Papaya's settled-payment events to suppress reminders.
Rocket Money — Subscription and bill management with negotiation features; pairs well with Papaya for recurring household bills the user wants to renegotiate or cancel.
Simplifi by Quicken — Modern personal finance with bill projections; consumes Papaya statement exports to forecast upcoming household outflows.
Bill.com — SMB AP/AR platform; often layered on top of Papaya when a small business wants OCR intake plus full ERP-grade approval flows.
BillGO — B2B bill-pay infrastructure used by banks and credit unions; appears in side-by-side evaluations against Papaya for consumer-bank embeds.
Mint — Long-running personal finance aggregator; users often want bill payments captured by Papaya to flow back as transactions in Mint-style dashboards.
Trim — Bill negotiation and subscription cancellation; complements Papaya by reducing the number of bills a user actually pays.
WellPaid — Bill management and reminders; integration value is unifying its tracking model with Papaya's payment events into one customer record.

What we deliver

Deliverables checklist

API specification (OpenAPI 3.1 / Swagger) covering Extract, BillPay and Statements endpoints
Protocol and authentication report (token lifecycle, webhook signing, retry semantics)
Runnable source code in Python (FastAPI) and Node.js (Express) — login, extract, pay, reconcile
Postman collection plus pytest / Jest test harnesses with sandbox fixtures
Compliance guidance: HIPAA data-minimization, PCI scope reduction, Regulation E disclosures
Optional hosted endpoint with metered, pay-per-call billing

About us

OpenFinance Lab is an independent studio focused on protocol analysis and OpenData / OpenFinance / OpenBanking integrations for mobile apps. Our engineers come from payments processors, neo-banks, healthcare RCM and security research. We have shipped end-to-end integrations against bill payment, neobank, brokerage and loyalty APIs for clients in North America, Europe, the Middle East and Asia.

Source code delivery from $300 — runnable API source code and full documentation; pay after delivery upon satisfaction
Pay-per-call API billing — access our hosted Papaya wrapper and pay only per call, no upfront cost
NDAs and data-processing addenda available for regulated workloads

Contact

For quotes, sandbox provisioning or to submit your Papaya integration requirements, open our contact page.

Contact page

Engagement workflow

Scope confirmation: which Papaya scenarios — OCR-only, OCR + payments, recurring, FSA/HSA, audit feed.
Protocol analysis and API design (2–5 business days, depending on data model complexity).
Build and internal validation against the Papaya BillPay sandbox (3–8 business days).
Documentation, sample apps and test cases (1–2 business days).
Typical first delivery: 5–15 business days; FSA/HSA enrollment with merchants may extend timelines.

FAQ

What do you need from me to start a Papaya: Pay Any Bill integration?

The target app name (provided), the integration scenarios you care about (e.g. OCR bill extraction, payment scheduling, statement export, webhook events), and any sandbox or merchant credentials you already hold with Papaya BillPay. We can also start from scratch and request sandbox access on your behalf.

How long does delivery take for a typical Papaya integration?

Usually 5–12 business days for a first API drop covering OCR upload, BillPay create/cancel, webhook subscription and a statement endpoint. End-to-end production rollouts with reconciliation, FSA/HSA flows and audit logs typically take 2–4 weeks.

How do you handle compliance for medical bills and card data?

We work with documented public APIs and authorized client credentials only. Card data is tokenized and never stored, healthcare bill workflows follow HIPAA-aligned data minimization with consent records and access logs, and PCI DSS-aligned handling is applied to all payment metadata.

Do you support both source code delivery and pay-per-call API access?

Yes. Source code delivery starts at $300 and includes runnable Python or Node.js code, OpenAPI documentation and sample tests. Pay-per-call gives you a hosted endpoint that wraps the Papaya BillPay and Extract APIs with our authentication, webhook fan-out and storage layer.

📱 Original app overview (appendix)

Papaya is a US fintech that lets anyone pay any bill by snapping a photo of it. Once a bill is captured, the company's computer-vision pipeline reads the relevant fields and routes the payment through ACH, debit, credit or FSA/HSA card on the user's behalf. The app is free to download and most payments settle within 24 hours.

How it works — Download the app, snap a picture of the bill, choose a payment method; Papaya sends the payment.
Bill coverage — Medical, dental, utilities, rent, insurance, loans, parking tickets, DMV, plumbing, business invoices, daycare, pet training and more.
Payment methods — Bank account (ACH), credit card, debit card and FSA/HSA card, subject to merchant acceptance.
Security — HIPAA and PCI compliant, bank-level secure; computer-vision technology co-developed with the lead engineer behind iRobot Roomba's vision stack.
Company — Founded 2016 in West Hollywood, CA; raised a $50M Series B in December 2021 led by Bessemer Venture Partners (~$65M total). Backed by investors behind Uber, Facebook, Google and YouTube.
Recognition — Winner of the PayAwards "Most Innovative Technology" award.
Developer surface — Public BillPay and Extract API documented at billpay.papayapay.com/docs, with REST endpoints, OCR upload and webhooks.