FlipPrice: Snap a Photo, Get a Price — Open-Source AI Makes Resale Pricing More Accurate

Anyone who does reselling knows the most time-consuming part isn't hunting for inventory — it's pricing each item, writing descriptions, and listing it. A box of 30 items can sink a side hustle just from the listing work alone. Developer existentialcoder submitted FlipPrice to the Hacktoberfest Open Source AI Challenge, aiming to solve this pain point with "a single photo" — snap a picture, get a price that will actually sell and a ready-to-publish listing.

What Problem It Solves

FlipPrice targets part-time sellers flipping old goods and garage-sale finds on eBay. The core workflow is dead simple: take a photo, and the app returns four things.

• A suggested price and range, based on similar items that have actually sold on eBay — not listing prices or a chatbot's guess
• The 5 closest sold records, viewable in one tap, so you can verify the price yourself
• Ready-to-publish listing copy that only describes what's visible in the photo — it won't fabricate claims like "works perfectly, well-maintained" that a buyer could hold you to
• It learns your pricing habits — after you mark items as sold, once a category accumulates enough sales records, FlipPrice prices based on your own history instead of the market average. For example, if you always sell vintage Levi's at 20% above market, the system remembers that

When the AI misidentifies something (the developer mentions one case where a Redragon gaming mouse was mistaken for a Logitech, causing the price to reference Logitech data), the user can just tap "Not right? Edit" to correct the brand or model, and the price recalculates immediately.

Who would pay for this: part-time resellers listing dozens of items per week. Their main cost is time, and pricing mistakes directly mean lost money. If a few dollars a month saves an hour or prevents one item from being undersold, the math is easy.

Demo: Starting with a Bottle of Perfume

The developer ran a real test with their own Engage Amber Hues eau de parfum.

Gemma reads the label and identifies the brand, line, category, and condition. The generated listing copy is 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. The reason: eBay search results were polluted with $170 niche perfumes, Avon six-piece sets, and a pile of other fragrances — extremely noisy data. The actual sold prices for Engage perfume fall between $27–$39.

After the filtering fix described below, the final price was $28 (range $27–$39), based on just 3 eBay sold records that genuinely belonged to Engage perfume.

Technical Architecture: Vision Recognition + Sold-Listing Retrieval + Personalized Pricing

The tech stack's division of labor is very clear:

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 Handles "Seeing" and "Writing"

Gemma 4 (26B-A4B, open weights) does two things in a single call: it reads the photo and returns structured fields (brand, model, category, condition, era), while simultaneously generating listing copy. Merging what would have been two calls into one saves about 15 seconds per photo.

The prompt is deliberately strict: the brand field returns "unknown" unless the logo is clearly legible. The reasoning is straightforward — a confidently wrong brand produces a confidently wrong price.

TabPFN is a tabular foundation model proposed by Prior Labs. It treats "making predictions on small tabular datasets" itself as a pretraining task: the model learns across millions of synthetic tabular datasets the meta-ability of "given a few rows of training samples, how to predict new rows." As a result, at inference time it doesn't need a gradient-descent-style training loop — it takes your few dozen rows of sales history as "context" directly, and produces a predictive distribution in a single forward pass. Its typical use case is precisely structured tables with tens to thousands of rows and mixed categorical/numerical features — which complements deep models that often need tens of thousands of samples. In FlipPrice, TabPFN returns the median and 25–75% quantile range. A range rather than a point estimate is especially important for pricing, because sellers need to know the trade-off space between "sells fast" and "sells high."

TabPFN Handles "Learning You"

TabPFN is the core of the "learn the seller's habits" feature. Your sales history is just a tiny table: a few dozen rows containing category, brand, type, condition, era, and sold price. That's far too little data to train a conventional model — but it's exactly where a tabular foundation model shines.

TabPFN fits your history on the fly at request time, running entirely in-process with no training pipeline, and returns a median plus 25–75% range. It only uses sales records from the same category, so jacket data won't be used to price a laptop.

SerpApi Provides Real-Time Sold Data

SerpApi pulls eBay's live sold listings, ensuring prices are anchored to what actually sold this week. MongoDB stores sales history, and FastAPI and Expo tie the whole system together.

SerpApi is a third-party API service that converts search engine results pages (SERPs) into structured JSON. It handles proxy rotation, CAPTCHAs, page parsing, and other scraping engineering problems, letting developers directly query "items sold on eBay for a given keyword" and get back fields like title, price, and sold date. Compared to scraping on your own, it avoids the cost of getting IP-banned and maintaining parsers — at the price of per-call billing, which is why FlipPrice only queries necessary keywords. It's worth noting that eBay's "sold" search is essentially fuzzy keyword matching and doesn't return structured brand or model fields; hits come back only as free-text titles — which is exactly why the title-based secondary filtering described below is necessary, and why you can't simply average the returned prices. MongoDB here handles persistence of sales history: it stores each transaction's structured fields (category, brand, condition, sold price) as documents, making it easy to slice by category and feed into TabPFN; FastAPI provides the backend HTTP interface and hosts the TabPFN inference process; Expo builds both iOS and Android clients from a single React Native codebase.

Three Key Lessons

The developer distilled three lessons worth the attention of any AI application developer.

Recognition Errors Cost More Than Pricing Errors

Searching "asus laptop" pulls in both low-end netbooks and high-end gaming laptops, with wildly different price ranges. Adding a model field and letting the user correct it matters more than any model choice.

Search Results ≠ Comparable Sales

eBay's "sold" search is fuzzy matching: search for one perfume and you get back thirty amber fragrances. FlipPrice's current strategy is to price only from results whose titles explicitly contain the model, then fall back to brand matching, and only use all results when fewer than 3 matches are found. This single filter pulled the perfume estimate from $65 down to an honest $28.

Hosted Model Endpoints Will Go Down

Gemma's API returned 500 errors during testing. The backend retries, then falls back to a second model. Every response logs which model wrote the listing, ensuring traceability.

Why Open Source Matters So Much for This Kind of App

Resale pricing depends on private data: how much you paid for inventory, how much you sold it for, which buyers are willing to pay more. A closed-source pricing API means uploading that history to someone else's server and getting back "the market as their model sees it" rather than "your market."

Here, TabPFN reads your sales data in-process on the backend — sales history never goes to a third party. And Gemma's weights are open, so the vision recognition step isn't locked into a single vendor — today you call Google's hosted endpoint for convenience, but the same model can run on a single GPU (or an even smaller Gemma version on a laptop). A seller or small resale shop can run the full version of FlipPrice on their own hardware, photos never leave the machine, and there's no per-image billing.

The developer's own words are precise: "Without open models, this is just a thin wrapper around someone else's API. With them, you own the pricing model that knows your business best."

The project is open source on GitHub (existentialcoder/flipprice), including the Expo client, FastAPI service, and a Remotion-made demo video. It was submitted across three categories: Best Use of TabPFN, Best Use of Gemma, and SerpApi.

Open weights is not entirely equivalent to "open source": it means the model's parameters can be downloaded and run by anyone, but the training data and training code aren't necessarily public. That distinction happens to be sufficient in this case — it guarantees the two key capabilities of "not being locked into a single vendor" and "data never leaving your machine." From an engineering standpoint, Gemma 4's 26B-A4B naming means the model has roughly 26 billion total parameters, but only about 4 billion are activated per token (A4B = activated 4B), so VRAM usage and inference cost are far lower than a dense model of the same scale — which is the precondition for it running on a single consumer GPU, or even a smaller version on a laptop. Quantized smaller models can typically compress memory usage further, at the cost of slightly lower recognition accuracy — often still acceptable for tasks like "snap a photo and identify brand and model."

One-line Summary

FlipPrice turns a single photo into secondhand item identification, pricing, and listing generation — with private sales data staying local.

Paragraph Summary

FlipPrice is a project submitted by developer existentialcoder to the Hacktoberfest Open Source AI Challenge, aimed at part-time eBay resellers. It takes one photo and returns a suggested price range, 5 comparable sold listings, and ready-to-publish listing copy. Its tech stack has three parts: the Gemma 4 vision model identifies brand/model/condition and generates copy in a single call, SerpApi pulls real-time eBay sold data, and TabPFN provides personalized pricing based on the seller's own sales history when enough samples exist. The developer's three core lessons: recognition errors cost more than pricing errors; eBay's "sold" search is fuzzy matching and must be filtered by model to be comparable; hosted model endpoints go down, requiring retries and fallbacks. In a real test, the filtering strategy corrected a perfume's estimate from $65 to $28, close to the true sold range of $27–$39. The project is open source, emphasizing that private data never leaves the machine and local deployment capability.