FlipPrice: snap a photo, get a price you can actually sell at

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

FlipPrice is a phone app for people who flip thrift-store and garage-sale finds on eBay.

The slowest part of reselling isn't finding stuff. It's the time spent on every single item working out what it is, searching sold listings, guessing a price and writing a listing. Multiply that by a box of 30 items and the side hustle stops paying.

With FlipPrice you take one photo and get:

• A suggested price and range, based on what similar items actually sold for on eBay, not asking prices or a chatbot's guess.
• The 5 closest sold listings, one tap away, so you can check the price yourself.
• A ready-to-post listing that only describes what's visible. No invented "works perfectly, well maintained" claims a buyer can hold you to.
• Prices that learn from you. Mark items as sold, and once you have enough sales in a category, FlipPrice prices from your own history instead of the market average. A seller who always gets 20% over market for vintage Levi's should see that in their prices.

When the AI gets something wrong (it once called a Redragon gaming mouse a Logitech, which pulled in Logitech prices), you tap "Not right? Edit", fix the brand or model, and it re-prices instantly.

Who would pay: part-time resellers who list dozens of items a week. Time per listing is their main cost, and a mispriced item is lost money. A few dollars a month is easily worth it if it saves an hour a week or stops one item going out underpriced.

Demo

A real run: I photographed a half-used bottle of Engage Amber Hues eau de parfum from my desk.

• Gemma read the label: Engage · Amber Hues · eau de parfum · good.
• The listing it wrote was plain and honest: "Engage Amber Hues Eau de Parfum. The item is in good condition. Please see the photos for more details."
• The first version of FlipPrice priced it at $65. eBay's search had padded the results with a $170 niche perfume, an Avon 6-pack and a dozen other scents. Engage perfumes actually sold for $27–$39.
• After the fix described below, it says $28 (range $27–$39), based only on the 3 eBay sales that are actually Engage perfumes.

Code

existentialcoder / flipprice

Hacktoberfest Week 2 challenge

FlipPrice

Photo → price + listing for side-hustle resellers. Gemma identifies the item, SerpApi pulls eBay sold comps, and TabPFN predicts the price from the seller's own sales history.

app/    Expo Router client: capture screen → result screen
api/    FastAPI: /analyze, /price, /sold, /history (TabPFN runs in-process)
video/  Remotion demo video

Run

# 1. API (needs MongoDB: local or Atlas URI)
cd api && python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
cp .env.example .env   # fill GEMINI_API_KEY, SERPAPI_KEY, MONGODB_URI, TABPFN_TOKEN
set -a && . ./.env && set +a && .venv/bin/uvicorn main:app --reload --host 0.0.0.0 --port 3000 --timeout-keep-alive 75
# 2. Optional: seed sales history (columns: category,brand,item_type,condition,era,sold_price)
jq -Rs '{csv: .}' sample-sales.csv | curl -s -H 'content-type: application/json' -d @- localhost:3000/history

# 3. App (open in Expo Go; phone and laptop on the same Wi-Fi)
cd app && npm install
printf 'EXPO_PUBLIC_API_URL=http://<your-lan-ip>:3000\nREACT_NATIVE_PACKAGER_HOSTNAME=<your-lan-ip>\n'

…

View on GitHub

• app/: Expo (React Native) app with Expo Router: capture screen → result screen
• api/: FastAPI service: /analyze, /price, /sold, /history
• video/: the demo video, built with Remotion

How I Built It

photo ──► Gemma 4 (vision) ──► brand / model / type / condition + listing text
                │
                ▼
        SerpApi eBay "sold" search ──► keep only titles naming the model / brand
                │
                ▼
   ≥10 of your sales in this category?
        yes ──► TabPFN regression on your own sales history (runs in-process)
        no  ──► median and quartiles of the eBay comps

Gemma 4 (26B-A4B, open-weight) does the seeing and writing. One call reads the photo, returns structured fields (brand, model, item type, condition, era) and writes the listing. Merging what used to be two calls into one saved about 15 seconds per photo. The prompt is strict on purpose: brand is "unknown" unless a logo is readable, because a confidently wrong brand produces a confidently wrong price.

TabPFN is where the "learns from you" part lives. Your past sales are a tiny table: a few dozen rows of category, brand, type, condition, era and sold price. That's far too little to train a normal model, and exactly what a tabular foundation model is built for. TabPFN fits on your history at request time, in-process, with no training pipeline, and returns a median plus a 25–75% range. It only uses sales from the same category, so your jacket sales never price a laptop.

SerpApi fetches live eBay sold listings, which keeps prices grounded in what's selling this week.

MongoDB stores sales history. FastAPI and Expo tie it together.

Things I learned building it:

• Identification errors cost more than pricing errors. A search for just "asus laptop" mixes budget netbooks with high-end gaming laptops. Adding a model field and letting the user correct it mattered more than any modelling choice.
• Search results aren't comparable sales. eBay's "sold" search is fuzzy: ask for one perfume and you get thirty amber-scented things. FlipPrice now prices only from results whose title names the model, falling back to the brand, and to everything only if fewer than 3 match. That one filter took the perfume from $65 to an honest $28.
• Hosted model endpoints fail. Gemma's API returned 500s during testing, so the backend retries, then falls back to a second model. Every response records which model wrote the listing.

Why Does Open Innovation Matter?

Resale pricing runs on private data: what you paid, what you sold for, which of your buyers pay more. A closed pricing API would need that history uploaded to someone else's servers and would give you their model's view of the market, not yours.

Here, the part that sees your sales, TabPFN, runs in-process on the backend, so your sales history never goes to a third party. And because Gemma's weights are open, the vision step isn't tied to one vendor. Today it calls Google's hosted endpoint for convenience, but the same model can run on a single GPU (or a smaller Gemma on a laptop). A seller or a small resale shop could run all of FlipPrice on their own hardware, photos included, with no per-photo bill.

Without open models this would be a thin wrapper over someone's API. With them, you own the pricing model that knows your business best.

My Agent Session

Prize Categories

• Best Use of TabPFN: personal price prediction from a seller's own small sales history
• Best Use of Gemma: Gemma 4 vision for item identification and listing generation
• SerpApi: live eBay sold-listing search grounds every price <!-- - MongoDB Atlas: only if you switch MONGODB_URI to an Atlas cluster -->