ReleaseGate

Pay when the work is proven, not when it is promised.

Comment

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for ReleaseGate

Inspiration

Freelance video work has a trust gap. Clients are afraid to pay before they see the result, and freelancers are afraid to deliver before they are paid. Escrow services exist but are slow and manual. PayPal's authorize-then-capture model fits the problem: a hold can be placed up front and only turned into a payment later, or released if the work is not delivered. ReleaseGate connects that hold to automated checks on the delivered file.

What it does

  1. The client writes a job brief and an amount.
  2. ReleaseGate turns the brief into a checklist (length, resolution, audio present, loudness, silence, black frames, on-screen text) and shows it to both sides before any money is held.
  3. The client's payment is authorized on PayPal (a hold). Nothing is charged.
  4. The freelancer uploads the video. ReleaseGate records its SHA-256 and runs the checks with ffmpeg/ffprobe and OCR.
  5. All required checks pass: the authorization is captured. A required check fails: the authorization is voided and the client is not charged. A required check cannot be verified (for example, no OCR installed): the job goes to HOLD for a human decision. It is never silently passed.
  6. Every step is written to an append-only, hash-chained evidence log in a "supported / unsupported / not verified" style, including the measured and expected values and the PayPal ids.

It also has a pre-flight mode so a freelancer can test a file against the checklist before delivering, with nothing settled.

How it uses PayPal

  • Orders v2 POST /v2/checkout/orders with intent: AUTHORIZE, one purchase unit, and an idempotency header (PayPal-Request-Id) derived from the job and action.
  • Authorize: in the demo the order is authorized with PayPal's public sandbox test card (the hold is placed during order creation). The code also has the normal buyer-approval path (payer-action link, then POST /v2/checkout/orders/{id}/authorize).
  • Payments v2 POST /v2/payments/authorizations/{id}/capture (with final_capture: true) when checks pass, and POST /v2/payments/authorizations/{id}/void when they fail.
  • Read-only GET calls on the order, authorization and capture are used to confirm the final state independently of ReleaseGate's own log.
  • The client refuses any host other than api-m.sandbox.paypal.com, so it cannot move real money.

How AI is used

  • At runtime: one small call to Claude Haiku 4.5 turns the free-text brief into a structured checklist. The output is validated against a fixed schema (known check types only, numbers clamped) and merged over a rule-based baseline. The brief is treated as untrusted text. The model cannot touch payments and does not make pass/fail decisions; those are made by deterministic code (ffmpeg, ffprobe, OCR). Without an API key, rule-based parsing is used instead.
  • While building: AI assistants were used to help draft and write the code, tests and this text. The author directed the work and reviewed the result.

How we built it

Python standard library only for the core (HTTP server, PayPal client, evidence log), ffmpeg/ffprobe for measurements, RapidOCR or tesseract for on-screen text, a single-page web UI, and a CLI. PayPal and Anthropic access use only the standard library's urllib. 43 automated tests run without network or secrets: the checkers run on small generated videos, and the PayPal and AI layers run against local fakes. Real sandbox runs were then done and read back from PayPal.

Challenges

  • The first real sandbox order was rejected because of an invalid payment_method_preference field that the local fake had accepted. Fakes cannot replace a real run, so the real sandbox flow was added to the checks.
  • Measuring "a voiceover" or "good quality" is not possible with simple checks. ReleaseGate only claims what it can measure, and says so in the checklist. For example, "voiceover" is checked as "an audio track exists".
  • OCR can miss short or stylised text, so a failed text check carries a note about that, and a missing OCR backend becomes NOT VERIFIED rather than a pass.
  • Keeping the AI step safe: schema validation, number clamping, caching, and no authority over money.
  • A browser run of the web UI found a JavaScript syntax error that the unit tests had missed. It was fixed and a syntax test was added.

What's next

  • Test and polish the normal buyer-approval flow with a logged-in sandbox buyer account (not tested yet).
  • Authorization expiry and re-authorization handling, partial captures, refunds and disputes.
  • Better checks (audio language and speech presence, scene and brand-safety rules) and per-job human review.
  • Other deliverable types (audio, images, documents).
  • Authentication, multi-user storage and a hosted version. Today it is a single-user local prototype with no login.

Built with

Python, PayPal REST APIs (Orders v2, Payments v2) in sandbox, Anthropic Claude Haiku 4.5 (runtime checklist), ffmpeg and ffprobe, RapidOCR / tesseract, HTML and JavaScript, pytest. AI assistants used while building: Anthropic's Claude (via a coding assistant) and an AI agent assistant.

Testing instructions (for judges)

No account is required to try the local flow.

git clone https://github.com/GitHubMoreLikeGitGud/releasegate && cd releasegate
python -m releasegate status          # shows the mode; "mock" means local simulation, NOT PayPal
python -m releasegate demo            # end to end on generated sample videos: a good file is captured, a short one is voided
python -m pytest -q                   # 43 tests, no network or secrets needed
python -m releasegate serve           # web UI at http://127.0.0.1:8765

Requires Python 3.10+ and ffmpeg/ffprobe on PATH. For on-screen text checks install rapidocr_onnxruntime or tesseract.

Mock mode: with no PayPal keys set, ReleaseGate uses a local mock. It is labelled "MOCK, not PayPal" in the UI, CLI and every evidence entry, and it makes no network calls.

Real PayPal sandbox: create a sandbox REST app in the PayPal developer dashboard and set PAYPAL_CLIENT_ID and PAYPAL_CLIENT_SECRET (sandbox values only). In the web UI click Authorize with sandbox test card, upload a file, and Run checks and settle; python -m releasegate verify JOB reads the state back from PayPal. ANTHROPIC_API_KEY is optional (AI checklist).

Honest limits

  • Prototype, single user, local only, JSON file storage, no login.
  • Verified against the real PayPal sandbox with the sandbox test-card path (authorize, capture, void, read-back). The wallet-login buyer flow is implemented but not tested against PayPal.
  • Checks measure technical properties only; they cannot judge whether a video is good or on-brief creatively.
  • The demo video is a screen recording of the real web UI against the sandbox, captioned, with no voice or music. It was produced with browser automation, not by hand.
Share this project:

Updates

Submission history