Receipts

An AI-powered citation verification and source discovery tool for academic writing.

Comment

Inspiration

AI can write a perfect-looking bibliography in seconds. The problem is that some of those papers don't exist. Chatbots invent studies with plausible titles, real-sounding journals, working-looking DOIs, and the names of real researchers attached to papers they never wrote. These fake citations already show up in student essays, articles, and even court filings.

Checking them by hand means searching database after database, one reference at a time. We wanted a tool that does that in one step, and that treats fabricated evidence for what it is: a fraud problem made cheap by AI.

What it does

Receipts has two modes:

  • Citation Audit: paste a citation or a whole bibliography in any style. Receipts checks each reference against real academic databases and labels it Verified, Details Don't Match, Not Found, or Can't Check. It catches DOIs that don't exist, DOIs that point to a different paper, wrong years and wrong authors, and shows a corrected citation for the real paper, ready to copy.
  • Find Sources: enter a claim and Receipts finds real papers about it. The AI reads each abstract and decides whether the paper actually supports the claim, then shows the exact evidence sentence, a short explanation, and a ready-made APA citation. Papers that only partly support the claim are marked Weak Support, so users don't overstate their evidence.

How we built it

  • Backend: Python and FastAPI, with two endpoints, /audit and /find.
  • Sources: Crossref, OpenAlex, Semantic Scholar, and the doi.org registry. Results from all of them are merged, duplicates are combined, and conflicting years are resolved.
  • AI: gpt-oss-120b via Groq, through an OpenAI-compatible helper, so the provider can be swapped by changing configuration only. The AI does three jobs: splitting messy reference lists, turning claims into search queries, and judging whether an abstract supports a claim.
  • Frontend: plain HTML, CSS, and JavaScript.
  • Deployment: frontend and backend on Vercel, deployed automatically from GitHub.

The core design rule: AI does the reading; real data does the deciding.

  • Every source comes from a real database, so the AI never invents a paper.
  • When the AI quotes evidence, Receipts checks that the quote actually appears in the abstract. If it doesn't, the result is downgraded.
  • A paper only counts as "Verified" support if the quote is one of the paper's own findings, not background or method.
  • The parser can't invent details: titles and years must appear in the pasted text, and DOIs are read straight from it.
  • Citations are formatted by code, not generated by AI.

Challenges we ran into

  • One paper, many copies. Famous papers exist as several records: the original, preprints, and later re-uploads. Our first version "corrected" a 2017 citation to 2025 because it found a re-upload first. We changed the matching to prefer the record whose first author and year agree with the citation, and to treat a 1-year gap as preprint vs. published.
  • Different papers, same title. "Deep learning" is both LeCun et al.'s 2015 Nature paper and Goodfellow et al.'s 2016 book. Merging by title alone mixed them into a fake citation, so same-title records now only merge when the first author matches.
  • AI judgments drift. Telling the AI to "be stricter" didn't work. Asking it to classify its own evidence as finding, background, or method, and letting code decide the label, did.
  • Rate limits and deployment. Semantic Scholar allows one request per second per key, so we added throttling, exponential backoff, caching, and fallbacks to the other databases. On the live server, a stray character in a pasted API key silently broke one source; we found it by adding a /health endpoint and made the code ignore whitespace in keys.

Accomplishments that we're proud of

  • A fact-checker that checks itself: every quote is verified against the source text.
  • It works end to end on a public live site, not just on a laptop.
  • It catches the exact patterns AI fabrication produces: invented papers, fake DOIs, real DOIs pointing elsewhere, and real papers with wrong details.

What we learned

  • Never trust a single source: databases disagree on years, titles, and versions, and cross-checking matters.
  • AI is most reliable when it does narrow, checkable jobs and code makes the final call.
  • Debugging deployments is its own skill: environment variables, caches, and what is actually running on the server.
  • Git, APIs, and keeping secrets out of public repositories.

What's next for Receipts

  • Checking full papers, not just abstracts.
  • A browser extension to check citations while reading or writing.
  • Uploading PDFs and documents to audit their reference lists directly.
  • Checking that in-text citations match the bibliography.
  • More citation styles, such as Chicago and other formats.
  • An accuracy benchmark with a labeled set of real and fabricated citations.

Built with AI assistance

AI coding assistants helped us write a partial fraction of the code. The AI inside Receipts is gpt-oss-120b, served by Groq. The demo narration was voiced with an AI text-to-speech tool.

Share this project:

Updates

Submission history