Inspiration

A post went viral joking about an app where you upload your bills and bored billionaires swipe right to pay them. Everyone laughed, and a lot of people said they would use it. The joke points at something real. In the US, 37% of adults would not cover a 400 USD emergency with cash, and one in six households is behind on utility bills. In India, a private school fee is often the biggest bill a family has, and almost nobody has a scholarship. When the gap is 60 dollars, the lights still go off.

Crowdfunding does not fix this. In a study of 437,596 medical fundraisers, only 12% reached their goal and 16% got nothing at all. A single small bill never gets a campaign. And givers hold back because they cannot see where the money goes: two thirds of donors say trust is essential, but fewer than one in five highly trust charities.

So I built the joke for real, with one rule that makes it safe: the money goes to the biller, never to the person.

What it does

Posters photograph a bill or upload a PDF. AI reads the biller, amount, currency, due date and account number. The poster checks the values, adds a few words if they want, and agrees to show a privacy-safe card. Billkind writes a short, dignified note from their words and removes names, numbers and addresses.

Nine checks run on every bill: verified biller registry, editing-software traces, visual signs of editing, two independent readings of the amount and date (a vision model and OCR), line items adding up, a typical amount, a sensible due date, duplicates, and posting velocity. Low-risk bills go live straight away. Others go to a person with every reason in plain words. An already-paid bill is refused.

Sponsors swipe through bills from around the world, shown in the bill's currency and their own. Swipe right, pick an amount, and pay with PayPal. Several sponsors can pool into one bill, and a 15-minute hold on the remaining amount stops two people overpaying. The payment sheet then shows each step as it happens: captured, fully funded, payout sent to the biller, the PAID stamp, and the thank-you from the household.

Billers receive one PayPal payout per bill, with the customer's account number in the note, so they credit the right account.

Big-sponsor mode: type "clear every school fee bill under 60 USD" and pay them all in one PayPal checkout. Each biller gets its own payout and each bill its own receipt.

Giving agent: write your rules in plain words ("up to 100 USD a month for children's school fees and medical bills, never more than 40 per bill"). AI turns them into limits you confirm. Save PayPal once with Vault, and the agent pays matching bills while you are away. The model proposes; code enforces the budget, the per-bill cap, the categories, countries and risk level. Every payment, clamp, skip and refusal is logged with the rule that applied.

Monthly sponsorship: after a bill you helped is paid, cover that household's next bill from the same biller automatically, every month, with your saved PayPal.

Support assistant: posters and sponsors ask "did the biller get my money?" or "why is my bill in review?". It reads only their own records, the policies, and their own PayPal orders through PayPal's Agent Toolkit. Every amount and ID in an answer is checked against what the tools returned; if anything cannot be confirmed, a safe answer from the records is shown and a person is one click away.

Impact studio: an AG Studio dashboard of what each sponsor's money did, and an operations dashboard for the team. It updates live as PayPal confirms payouts, has two custom widgets (the money path and a paid ledger), and an assistant built on Studio's Agent Framework adds widgets from plain-words requests.

Live wall: a public map and feed of bills being cleared around the world, with counters for bills cleared, countries, sponsors and amounts paid to billers. Every number comes from recorded transactions.

Refunds are automatic: if a bill is withdrawn, expires unfunded, cannot be paid out to the biller, or someone else covers it first, PayPal refunds the sponsor and the dashboard shows it.

Why it's different

Plenty of people built the viral joke after it went around. The ones I found say on their own sites that no money moves. Billkind moves it. Every payment on the demo is a real PayPal sandbox order, captured, then paid out to the biller with PayPal Payouts, and every receipt carries the order, capture and payout IDs so you can check them.

The money never touches the person who posted. That one rule removes the reason most people distrust crowdfunding, and it lets a stranger give 20 dollars without wondering where it went.

It's built for the bills nobody starts a campaign for: a 60 dollar power bill, a school fee, a clinic visit. And it's ready for agentic payments. Tell the giving agent your rules once and it pays matching bills while you're away, but the budget, the per-bill cap and the allowed billers live in code the model can't talk its way past. Tests try to make it overspend and it can't.

Under the hood it uses eight PayPal surfaces together: Orders, Payments, Payouts, Vault, Webhooks, the JS SDK, the Server SDK and the Agent Toolkit.

How I built it

Python and FastAPI with server-rendered pages and SQLite. The only JavaScript is the swipe gesture, server-sent events and the PayPal JS SDK. Hosted on an Oracle Cloud VM in Docker behind Caddy.

PayPal: Orders v2 for every payment, with one item per bill so a whole group of bills is one checkout. Payments v2 for full and partial refunds. Payouts v1 to pay billers, one batch with one item per bill. Vault v3 so the giving agent and monthly sponsorships can pay without the sponsor present. Webhooks verified with PayPal's CRC32 and SHA256withRSA scheme, with the verification API as a fallback, driving an explicit state machine; a buyer who approves and closes the tab still gets captured from the CHECKOUT.ORDER.APPROVED webhook. Orders, Payments and Vault calls go through PayPal's official Python Server SDK, generated by APIMatic. The support assistant reads orders through PayPal's Agent Toolkit for Python.

AI: open models on Groq. qwen/qwen3.8-27b reads bill photos; openai/gpt-oss-120b reads PDF and OCR text, writes the notes, parses plain-words rules, drives the giving agent and answers support questions with tool calls. Every AI feature has a non-AI fallback (Tesseract OCR, regex parsers, templates, rule-based picking), and no AI output alone can move money.

To build without waiting on credentials, I wrote a local fake of every PayPal endpoint Billkind uses, following the documented request and response shapes, error codes and signed webhooks. 88 automated tests run against it (one of them, a contract test against the real PayPal sandbox, runs only when switched on), including contract tests that send every call through both the APIMatic SDK and plain REST.

AG Studio: the Impact studio pages load AG Studio 3.1 with data sources built and scoped on the server, report pages defined as Studio state, two custom widgets, the Billkind theme, and live updates applied as data engine transactions. Its assistant is a Billkind agent in Studio's Agent Framework (a client tool runner) whose rounds go through my server to the open model, acting through a custom Studio tool that places widgets.

Challenges I ran into

  • Making it safe without making it slow. Paying the biller instead of the person removes the main fraud incentive; the nine checks handle the rest. The hard part was false positives: bills from one school share a template, so a similar image alone is normal. A near-duplicate image now only counts when the amount matches too.
  • Money races. Two sponsors paying the last 30 dollars at once, or a buyer approving after their hold expired. Holds prevent most of it; a late capture is accepted and the excess refunded automatically.
  • Currencies. PayPal does not settle INR, KES or NGN cross-border, so those bills settle in USD at a rate shown on the card, while GBP, EUR, MXN and PHP bills pay out in their own currency.
  • A busy vision model. When the vision model was over capacity, uploads stalled. Now a text model reads the OCR text in parallel and takes over if the vision model is slow.
  • Keeping the AI honest. The giving agent cannot be trusted to respect a budget, so the budget lives in code. The support assistant cannot be trusted with numbers, so every number is checked against its tool output.

Accomplishments that I'm proud of

  • A complete loop that works end to end on the hosted demo: post, verify, swipe, pay, payout, PAID stamp, receipt, thank-you, live wall.
  • Photo to structured, redacted bill card in about 4 to 7 seconds on the hosted demo.
  • A giving agent whose decision log shows payments, clamps and refusals with the rule behind each one.
  • 88 automated tests, including forged and replayed webhooks, overfunding races and an agent that tries to overspend.

What I learned

Trust is a product feature, not a disclaimer. Once the money path is "you, PayPal, the biller", most of the hard questions get simpler. And agents are most useful when they choose and explain while code holds the limits.

What's next for Billkind

Onboarding real billers (schools and clinics first), KYC for posters above small amounts, a PayPal platform model where the biller is the payee directly, and SMS posting for people without smartphones.

To be clear about geography: in the demo every biller is paid into one US sandbox business account, bills in USD, EUR, GBP, MXN and PHP pay out in their own currency, and bills in INR, KES, NGN, GHS, ZAR and IDR settle in USD. A PayPal business account in the India region gets PAYOUT_NOT_AVAILABLE, so an Indian school would need a PayPal-supported payout region or a partner payout rail; the first real audience is US households and US billers paid in USD, such as utility shutoff notices under 100 USD.

PayPal APIs used

Orders v2 (create, get, capture, vault_id payments), Payments v2 (refunds), Payouts v1 (batches and items), Vault v3 (setup and payment tokens), Webhooks (self-verification and the verify API), JS SDK Buttons, the PayPal Server SDK for Python (generated by APIMatic) and the PayPal Agent Toolkit for Python.

AI tools used

Groq API with open models qwen/qwen3.8-27b (vision), openai/gpt-oss-120b and openai/gpt-oss-20b (text and tool calling). AG Studio's Agent Framework for the dashboard assistant. Tesseract OCR as the non-AI fallback.

Sponsor tools

AG Grid: the Impact studio is built on AG Studio 3.1, with server-scoped data sources, custom widgets, theming, live data transactions and a custom agent in the Studio Agent Framework. Details in the README section "AG Studio: the Impact studio".

APIMatic: Billkind's Orders, Payments and Vault calls use PayPal's official Python Server SDK, which is generated by APIMatic (paypal-server-sdk 2.4.0).

Try it

Live demo: https://billkind.140-245-16-129.sslip.io

Code: https://github.com/vignesh2027/billkind

Sign in with the one-click demo accounts on the sign-in page (no password). Full walkthrough and sandbox buyer login in the README, section "Try it in two minutes".

Video credits

Music: "Light Thought var 1" Kevin MacLeod (incompetech.com), licensed under Creative Commons: By Attribution 4.0 License, http://creativecommons.org/licenses/by/4.0/

Built With

Share this project:

Updates

Submission history