Inspiration
Americans throw away about 9.7 million tons of furniture a year, and most of it goes to landfill (EPA). Much of it is perfectly usable. It just doesn't find the next owner in time. We've all seen it as students: move-out week, desks and lamps on the curb, while someone a mile away is paying full price for the same thing new.
When we tried buying secondhand ourselves, we kept running into the same three problems:
- It's scattered. The same search has to be repeated on Craigslist, Facebook Marketplace and eBay.
- You can't tell if it fits. A photo doesn't tell you whether a dresser fits your room, or your car.
- The "deal" isn't the real price. A $20 table 25 miles away costs more than $20 once you count the drive. Plenty of listings are already sold by the time you message.
So people give up and buy new, and the used item stays on the curb. We wanted to remove every one of those excuses. The goal is to keep furniture in use and out of landfills.
What it does
FitCheck is one search across every local marketplace, where you can see each item in your room at its real size before you drive anywhere.
For buyers
- Say what you want. Hold the mic and say "desk lamp and side table under forty dollars, warm wood." FitCheck turns that into filters you can see and edit as chips: categories, budget, style, distance and your car.
- One search, every marketplace. Results come from Craigslist, Facebook Marketplace and eBay together. They're ranked by meaning, so "warm wood" matches by look, not just by the title text.
- The true cost. Each card shows what the item really costs you: the price plus the round-trip drive, or the shipping cost when an item ships.
- Will it fit in your car? Tell it your car and every card gets a badge: fits, fits with seats folded, or too big.
- See it in your room. Items open in AR at their real size, on iPhone (AR Quick Look) and Android (Scene Viewer), with no app to install.
- Still listed? When you open a listing, FitCheck checks the live page so you don't drive to something already sold.
- QR handoff. Any item can be opened on another phone by scanning a QR code.
For sellers
- Take one photo and type what it is. It can be anything: a chair, a lamp, a water bottle.
- Gemini estimates width, depth and height (you can edit them), and FitCheck suggests a fair price from comparable local listings.
- A progress bar with an estimated time left shows FitCheck building a real 3D model from your photo, so buyers can place your item in their room.
- With one tap, the listing text and photo are ready to post to Facebook Marketplace, Craigslist and eBay.
Impact page. Live counters from our own database: listings indexed, free items available, AR placements, and pounds of furniture kept in use.
How we built it
Architecture
┌───────────────────────────── Bright Data ─────────────────────────────┐
│ Datasets: Facebook Marketplace, eBay Web Unlocker: Craigslist │
└──────────────────────────────────┬────────────────────────────────────┘
│ raw listings
▼
┌──────────────────────────── Python worker ───────────────────────────────┐
│ Gemini Vision ── tags category, style, condition, size, weight │
│ Gemini Embeddings ── vector per listing │
│ BiRefNet cutout → Meshy image-to-3D (TRELLIS fallback) → GLB + USDZ │
└───────────────┬──────────────────────────────────────────┬───────────────┘
│ listings, details, vectors, job state │ 3D files, photos
▼ ▼
┌──────────────────────┐ ┌──────────────────────┐
│ Neon Postgres │ │ Vercel Blob │
│ + pgvector │ │ GLB / USDZ / images │
│ (also the job queue) │ └──────────┬───────────┘
└──────────┬───────────┘ │
│ one hybrid SQL query │
▼ ▼
┌────────────────────────── Next.js on Vercel ─────────────────────────────┐
│ 🎤 ElevenLabs STT → Mastra agent (Gemini) → search tool → results │
│ 🔊 ElevenLabs TTS reads back the count │
│ Seller API: photo → Gemini measures → fair price → queues 3D build │
│ Live "still listed?" check via Bright Data Web Unlocker │
└──────────────────────────────────┬────────────────────────────────────────┘
▼
📱 Phone: <model-viewer> → AR Quick Look (iOS) / Scene Viewer (Android)
The pieces
Frontend and API: Next.js 16 + TypeScript on Vercel. The site and all API routes run as serverless functions. 3D models are shown with <model-viewer>, which hands off to AR Quick Look (USDZ) and Scene Viewer (GLB) at real-world scale.
Data collection: Bright Data.
- Datasets for Facebook Marketplace and eBay listings.
- Web Unlocker for Craigslist, which blocks ordinary scrapers. It also powers the live "still listed?" check, which fetches the original listing page when someone opens an item.
Understanding listings: Gemini.
- A vision model reads each listing's photos and text. It tags category, style, condition, approximate weight, and dimensions when the seller didn't give them.
gemini-embedding-001turns each listing into a vector so search can match by meaning.
Voice and search: ElevenLabs + Mastra + Gemini.
- ElevenLabs speech-to-text transcribes the query.
- A Mastra agent, running on Gemini, extracts structured filters and calls our search tool.
- The search tool runs one SQL query on Neon that combines hard filters with vector similarity.
- ElevenLabs text-to-speech reads back how many results it found.
Database: Neon Postgres + pgvector. One database holds listings, AI-extracted details, embeddings, 3D asset states and seller drafts. It also serves as the job queue for the 3D pipeline.
The cost shown on each card for a pickup is
$$ C_{\text{total}} = p + 2\,d_{\text{road}} \cdot f $$
where $p$ is the listing price, $d_{\text{road}}$ the road distance and $f$ the cost of driving per mile. For shipped items, the shipping cost replaces the drive. Car fit compares the item's bounding box $(w, d, h)$ with each car's cargo opening and cargo-space dimensions, first with the seats up and then with them folded.
Results are ordered so that items with a 3D model come first. Within each group they're ranked by a combined score: semantic similarity plus price and distance. When you ask for two kinds of furniture, the results alternate between them so one category doesn't push out the other.
Seller pricing. The suggested price comes from comparable local listings. For items with no local comparables, Gemini estimates a used price.
3D pipeline: a Python worker. The worker polls Neon and moves each item through these stages:
queued → cutout → generate → export → ready
- Cutout: BiRefNet removes the background from the photo.
- Generate: Meshy image-to-3D builds the model, with Hugging Face TRELLIS as a fallback.
- Export: the model is scaled to the item's real measured dimensions and exported as GLB and USDZ. It's uploaded to Vercel Blob, and the site picks it up automatically.
Challenges we ran into
- Craigslist blocks scrapers. Plain requests get blocked or CAPTCHA'd. Bright Data's Web Unlocker got us reliable access, and it also made the live "still listed?" check possible.
- Marketplace data is messy. Many listings don't give dimensions, some say "OBO" in place of a price, and the photos are cluttered. Gemini Vision fills in the gaps, and we clearly mark which values are estimated.
- The 3D has to look like the item, not an item. AR is only offered for a model built from that listing's own photos. That way, what you place in your room is the actual thing you'd pick up.
- True-to-life scale. A model that's 20% off is useless for "will it fit?" Every model is rescaled to the item's measured width, depth and height before export, so it appears at real size in AR.
- Sellers can photograph anything. A water bottle and a dresser fill a photo very differently. We tuned the cutout so a seller's item is detected cleanly, whatever its size.
- Generation takes time. We didn't want a spinner with no information, so we built a progress bar with an estimated time left that follows each pipeline stage, using live progress from Meshy.
- Turning a sentence into a database query. "Under forty, warm wood, I drive a Civic" mixes hard limits with taste. We split it: the Mastra agent extracts the hard filters for SQL, and vector search handles the style.
Accomplishments that we're proud of
- Voice to results in seconds: speech, structured filters, one hybrid SQL query, and a spoken count.
- Real AR at true scale, built from the listing's own photo, which works on both iPhone and Android with no app install.
- Costs that include the drive and car-fit badges, which address the real reasons people give up on used furniture.
- A seller flow that works for any item: photo → measurements → fair price → 3D model → ready to post on three marketplaces.
- A real data pipeline end to end: live listings from three marketplaces, a queue in Postgres, and a worker producing real 3D assets.
What we learned
- AI is only as good as the data around it. Much of our work went into validating and structuring what the models return, so the results stay trustworthy.
- Transparency builds trust. Clearly marking which values are estimated makes the precise ones more believable.
- Slow work belongs in the background. Using Postgres as a job queue with a separate worker keeps the site fast while 3D models build.
- One database can do a lot. Neon with pgvector handles relational filters, vector search and job state, which kept the system simple.
- We also got hands-on with tools new to most of us: Mastra agents, Bright Data's Web Unlocker, Meshy, USDZ/GLB export, and AR Quick Look.
What's next for FitCheck
- Direct posting: publish a seller's listing to Marketplace, Craigslist, and eBay from FitCheck through their APIs.
- A 3D model for every listing, with generation on hosted GPUs.
- Room-aware search: scan your room once and filter for items that actually fit the space.
- Free-item rescue: alert people nearby when a free item is posted, and partner with campuses during move-out week and with reuse nonprofits for pickup.
- Better impact data: track items that actually changed hands as well, so we can measure the pounds kept out of landfill more precisely.
Built With
- ar
- birefnet
- blob
- css
- elevenlabs
- face
- gemini
- hugging
- mastra
- meshy
- model-viewer
- neon
- next.js
- pgvector
- playwright
- postgresql
- python
- react
- tailwind
- trellis
- typescript
- webxr