HeyList

HeyList turns one sentence into a shared shopping list, buys with PayPal, reads your receipts with AI, and settles everyone up to the cent.

Comment

Inspiration

Group trips are fun. The money around them isn't. A Harris Poll for CIT Bank (May 2026) found that 82% of people who took a group trip would rather pay more than their share than argue about money, and 45% have had money conflict on a trip. We've all been in that group chat: Who's buying what? Who already paid? Who owes whom?

Checklist apps track tasks, and payment apps move money. Nothing connects the two, so "is this actually done, and who paid for it?" is always answered by memory. We wanted one shared list that goes from what we need to everyone settled up, with proof at every step.

What it does

Type one sentence ("photo trip this weekend for 3 people") and AI writes the shopping list, priced at real stores (Kroger for food, Walmart and Target for the rest). Mark what you already own and it drops off the budget. Share a link and friends join with just a name: no app, no sign-up. Then:

  • An AI shopping assistant finds real products and builds a cart that fits the budget. You approve it and pay once with PayPal, Venmo or Pay in 4.
  • Snap a receipt after buying in a store. AI reads every line, matches it to the list, takes coupons off the right item, and checks that the prices add up to the receipt's own total.
  • Settle up. HeyList knows what each person really paid, including tax, and works out who owes whom. It writes a friendly reminder, and one tap sends the money straight to the person owed with PayPal.

Every item shows how we know it's done: Paid with PayPal, On a receipt, Marked bought by hand, or Already had.

How we built it

  • Frontend: Next.js 16, mobile-first, with live updates between phones over Supabase Realtime.
  • Backend: FastAPI, Supabase (Postgres, storage, auth), deployed on Render with a cron job that finishes pending payments.
  • PayPal: the Python Server SDK for Orders v2 and Payments v2 (refunds), JS SDK v6 buttons for PayPal, Venmo and Pay Later, and signature-verified webhooks. Prices are set on the server, never taken from the browser.
  • AI: an Ollama vision model (gemma4:31b) writes lists, checks store matches, matches receipts and drafts reminders. AWS Textract reads receipts. Channel3 and Kroger's API supply real products and prices.

Our core rule: the AI proposes, code decides. Budgets, the cart fit, tax and the split are plain code, and a person confirms every AI suggestion.

All money is integer cents. Sales tax is stored as a rate r in basis points (825 = 8.25%) and charged per unit, rounded exactly the way PayPal checks it, where c is the unit price in cents:

$$\text{tax}(c) = \left\lfloor \frac{c \cdot r + 5000}{10000} \right\rfloor$$

To settle up, every member gets a balance: what they paid minus their fair share. The balances always add up to zero:

$$b_i = \text{paid}_i - \text{share}_i, \qquad \sum_i b_i = 0$$

Whoever owes the most pays whoever is owed the most, until everyone is at zero. That takes at most n − 1 payments for n people.

Challenges we ran into

  • "Completed" doesn't mean paid. A PayPal order can be COMPLETED while its capture is still PENDING or DECLINED. We check items off only on a completed capture, use idempotency keys so a retry never charges twice, and refund automatically if two people buy the same item.
  • LLMs ignore schemas. Our model wrapped its JSON in code fences and dropped fields. We now pull out the JSON, repeat the schema in the prompt, and validate every field in code with a safe fallback.
  • Never guess a price. The receipt reader's confidence score alone caught few wrong prices. What worked was checking the receipt against itself: the lines must add up to the receipt's own subtotal. In our tests, every receipt with a wrong price failed that check. A price that can't be read surely is left blank for a person to type, never invented.
  • Real prices are hard. Our product search had no real groceries (searching "hot dogs" returned plush toys), so food is priced from Kroger's API instead.
  • Keeping the agent safe. The shopping assistant proposes a cart but can never pay on its own. A person approves every payment on PayPal's page.

The receipt check, where each line's price is p:

$$\sum_{\text{lines}} p_\ell = \text{subtotal}$$

Accomplishments that we're proud of

  • The whole loop works end to end: one sentence becomes a priced list, the list gets shared, items are bought with PayPal or proven with a receipt, and everyone is settled up to the cent.
  • Payments a real group could trust: checked off only on a completed capture, no double charges, automatic refunds for double purchases, and money going straight to the friend who's owed, never through us.
  • AI we measured instead of assumed: our 30-case evaluation finds 96 of 98 list items with zero invented ones. Across 289 real receipts, Textract shows a wrong price on 2.5% of lines on the 189 English ones, and reads the tax correctly 97% of the time.
  • Real-world money details: sales tax on PayPal orders (Items + Tax = Total), coupons taken off the right item, and tips and fees counted in the split like on a real receipt.
  • No app, no sign-up: anyone with the link can join from their phone's browser.

What we learned

  • Measure the AI instead of trusting it. Our evaluation showed that adding example lists to the prompt made results worse (91/98 vs 96/98), the opposite of what we expected.
  • Money code needs a different mindset: integer cents, idempotency, checking payment status twice, and handling failure paths (pending, declined, refunds) as first-class features.
  • The best AI features are small and checkable: AI suggests, code verifies, people confirm.

What's next for HeyList

  • Placing the real store order once Channel3's checkout opens, so the agent buys as well as finds.
  • Weighted shares, for when one person covers two people or a couple splits as one.
  • Recognising several items in one photo, like a packed bag, to check them all off at once.
  • Testing with real groups to measure whether HeyList actually ends the money arguments.

Built With

  • apimatic
  • aws-textract
  • boto3
  • channel3
  • fastapi
  • httpx
  • next.js
  • ollama
  • paypal
  • paypal-js-sdk
  • paypal-orders-api
  • paypal-pay-later
  • paypal-payments-api
  • paypal-server-sdk
  • paypal-webhooks
  • python
  • react
  • render
  • supabase
  • typescript
  • uvicorn
  • venmo
  • web-speech-api
Share this project:

Updates

Submission history