Short description
RightsReceipt helps independent creators turn a vague request to use their image into a precise, human-approved licensing proposal. It makes twelve material rights fields reviewable, prices the agreed scope with a deterministic creator policy, records separate creator and buyer decisions, and ties the resulting permission state to authoritative payment evidence.
The demo includes a real local trained-model diagnostic and a working application-handler rehearsal. The rehearsal uses scripted participants and injected PayPal-like responses. It does not claim a completed PayPal Sandbox payment, verified paid webhook, or legally issued real-world license.
Inspiration
“Can we use this photo in an ad?” sounds like a straightforward request, but it leaves major questions unresolved. Which channels and territories? For how long? Is alteration allowed? Must the creator receive attribution? Are exclusivity, sublicensing, or AI training permitted?
For small creators and buyers, these questions are often negotiated in fragmented messages. A payment alone does not prove that both parties understood the same rights. RightsReceipt addresses that gap by making the proposed scope explicit before money changes hands.
What it does
The focused prototype models one commercial image-license journey:
- A buyer states intended use in ordinary language.
- A source-grounded extractor identifies explicit terms and flags missing or contradictory rights. A separate learned classifier offers read-only suggestions.
- The creator reviews and resolves all material terms.
- A versioned policy calculates an integer-cent quote. AI cannot set the price.
- The buyer accepts the exact approved offer version.
- The PayPal integration is designed to create/send an invoice and reconcile payment status with verified provider evidence.
- A canonical SHA-256-checked permission receipt binds the scope, approvals, quote and financial state. Public verification exposes a minimized view.
The seeded case involves creator Maya Chen, buyer Cedar & Tide, the fictional image Harbor After Rain, and a USD 425.00 quote. Recovery safeguards handle an interrupted invoice-send response without silently creating a duplicate.
How AI is used
RightsReceipt uses two deliberately separate approaches:
- A deterministic source-span extractor that preserves the buyer's supporting words, shows uncertainty, and requires clarification of unresolved material rights.
- A small supervised lexical classifier trained with Python and scikit-learn on project-authored synthetic examples. Its SHA-256-verified quantized weights are evaluated locally by TypeScript. It suggests labels across twelve rights fields, but its margins are not calibrated probabilities.
The video runs the actual local classifier on two synthetic requests and visibly demonstrates a territorial contradiction: the model suggests the United States and Canada even when the request also says Germany only. That error is surfaced for human resolution. AI has no authority to approve permission, accept an offer, set pricing, establish ownership, or confirm payment.
How PayPal is used
The implemented PayPal Sandbox integration covers OAuth authentication, Invoicing v2 draft creation and sending, PayPal-hosted buyer handoff, authenticated invoice-status retrieval, webhook signature verification, and reconciliation of payment-linked permission state. PayPal is central because the app must never treat a browser redirect or AI output as settlement evidence.
Evidence distinction: The available judge rehearsal exercises application logic with injected PayPal-like provider responses, not an actual external PayPal call. A separate-buyer paid Sandbox invoice, matching authenticated PAID retrieval, and signature-verified paid webhook have not been independently demonstrated. No live money is moved in this demo, and no real license is granted.
How we built it
The application uses TypeScript, React, Hono, Vite, a Cloudflare Worker/D1-oriented architecture, and deterministic local database verification. The pricing policy uses exact integer-cent arithmetic, while receipts use canonical serialization and SHA-256 integrity checks. The trained model is packaged for local inference with no paid hosted AI service required for the judge diagnostic.
The public source snapshot includes a dependency-free local judge console, deterministic regression coverage, evidence checks, and a guide for genuine PayPal Sandbox acceptance. The public repository was created from an audited, sanitized source snapshot without the private development history.
Challenges
The most difficult design problem was separating seven different forms of authority: the buyer's request, AI suggestions, creator-approved terms, buyer acceptance, policy-calculated price, PayPal-confirmed financial state, and active permission.
Network retries and webhook timing add another challenge. An invoice send can succeed at the provider even when the local response is lost. RightsReceipt uses stable operation identities, read-back and reconciliation so an ambiguous reply does not silently become a second invoice or a permission grant.
Accomplishments
- A coherent end-to-end local licensing application rehearsal with three verified scripted journeys and three database resets.
- A deterministic USD 425.00 quote and separate creator/buyer approval records.
- Invoice-send recovery and stale-replay rejection in the local rehearsal.
- A minimized, tamper-evident receipt workflow.
- Real local inference by the bundled classifier on two synthetic requests, with 24 rights-field comparisons and an explicit contradiction warning.
- A public, MIT-licensed source checkout that completed the functional judge-console smoke and standalone actual-model proof on Node 22.16.0 on November 10, 2026.
These accomplishments are local software and test evidence. They do not prove a genuine paid PayPal transaction, provider webhook delivery, real-world model reliability, or legal rights ownership.
What we learned
Useful AI does not always need the last word. In a licensing workflow, the best result can be a clear explanation of what is known, what conflicts, and which human must decide.
Payment systems benefit from the same discipline. A receipt is only as trustworthy as the exact consent and provider state it represents. Explicit limits and reproducible evidence make a prototype more credible than a polished claim that cannot be tested.
What's next
Complete genuine separate-buyer PayPal Sandbox acceptance with a matching authenticated paid invoice and verified webhook. Add real creator identity and ownership checks, evaluate extraction against real-world labeled requests, broaden configurable licensing policies, and investigate external receipt signing. A hosted judge preview remains optional; the submitted source already includes a runnable local evaluation path.
RightsReceipt is not legal advice and does not itself prove copyright ownership.
Functional demo
Required public repository: https://github.com/nolankido/rightsreceipt-hackathon
From a complete public checkout, use Node 22.13 through 22.x. No account, package installation, secret or paid API is needed for the local judge experience:
node scripts/judge-local-console.mjs
Open the printed localhost URL. Select Run application rehearsal to execute three real application-handler journeys with scripted participants and simulated financial replies. The successful report shows three resets and zero external requests. Then select Run read-only AI diagnostic to execute the separate trained model on synthetic terms.
Automated command-line proofs:
node scripts/judge-console-real-smoke.mjs
node --no-warnings --experimental-strip-types scripts/judge-ai-proof.mjs
The public repository contains historical engineering documents written before the sanitized source was published. Its public availability and the November 10 local checks are verified separately; historical “not yet public” statements describe an earlier project state. The repo is a frozen public snapshot, not a mirror of every later private development revision.
Video
YouTube: https://youtu.be/AzUeM4lXyuA
The approved upload is a 174.021-second, 1080p captioned local application/AI demonstration animatic with explicit simulated-payment disclosures and a proof end card. The timed captions were generated from the narration draft and are not independently certified as an exact transcript. This is an edited demonstration, not an uninterrupted recording of a live external PayPal payment. Public playback and duration were observed on YouTube November 10, 2026.
Tools used
- PayPal Developer Platform and Invoicing v2 Sandbox adapter
- Python and scikit-learn (SGDClassifier), for synthetic lexical-model training
- Portable TypeScript local inference with SHA-256-checked weights
- Deterministic source-span extraction and human clarification
- TypeScript, React, Hono, Vite
- Cloudflare Worker/D1 architecture
- Web Crypto SHA-256 and deterministic receipt verification
- Node.js, Vitest and local application-handler regression tests
