TrueCopy

Translation is the easy part. TrueCopy refuses to publish any language it can't prove kept every link, timestamp and handle intact, then makes YouTube confirm what it wrote.

Comment

What makes this different, in one paragraph

TrueCopy is the only tool I know of that will refuse to publish a translation. It names the rule that was broken and the exact token that went missing. Then, for the languages that pass, it makes YouTube itself confirm what was written. The refusal is the product. Translation is a dependency: swap Gemini for Claude with one property and nothing about the guarantee changes.

The model writes, the gate decides, and the platform confirms.

Check that in sixty seconds, right now, without signing in to anything

The live instance opens on my real YouTube channel in read-only demo mode. No account, no OAuth, no install.

  1. Open truecopy.onrender.com/workspace, wait for the video list to load, then click "Rack Demo for DevNetwork [API + Cloud + AI] Hackathon" in the sidebar. Now press "Audit existing translations". About a second, no model involved. German comes back REFUSED (2), and scrolling down shows the diff naming both missing tokens: a shop link pointing at the wrong domain, and a chapter timestamp rewritten as prose.
  2. Click a language on What a viewer sees. That panel is videos.list with hl=, read live from YouTube. It is YouTube's answer, not mine.
  3. Open the playground, press break it for me, then Re-check gate. Verified becomes refused, with the rule named.

Live writes are disabled on that instance, and demo sessions are refused at the publish path independently of that setting, so everything you see is real against a real channel but nothing you do can change my videos.

Repo, tests and CI: github.com/sidharthnair7/truecopy. First commit 6 September 2026. Every line was written inside the submission window, and the public commit history shows it.

This is not a translation tool

I will name my own competition before you have to. Bulk YouTube localization already exists. ReTranslate does titles and descriptions in 160+ languages with OAuth and protected terms. TubeBuddy sells AutoTranslate on its top tier. If all you want is text turned into other languages, you are already served, and TrueCopy would be a worse version of those products.

Every one of them gates on a human reviewing each language before it goes out. That is a sound rule that stops working the moment the creator cannot read the language, which is the entire situation localization exists for. Nobody can review Japanese they do not speak, so in practice the review is skipped and the translation ships unchecked.

TrueCopy gates on a deterministic machine check instead of a person, and it is allowed to say no. Seven rules over the source and the translation, no model in the loop, identical verdict every time. If one link changed, one timestamp turned into prose, one handle got translated, that language is refused and the report names the rule and the exact token.

Inspiration

In February 2026 YouTube switched on auto-dubbing for every creator. A video uploaded in English now gets a Spanish, French or Japanese audio track for free, with no opt-in. The title and description a Spanish viewer sees, though, are still English, or Google's machine translation of English, which viewers have been publicly complaining about since last July.

Localized titles and descriptions have been a free native YouTube feature for years. Almost nobody uses it, because you cannot review eight languages you do not speak, and an AI translation you cannot check is not something you publish to a channel that pays your rent. Naive translation rewrites URLs, turns "12:34" into prose, translates @handles and brand names, and quietly breaks the affiliate link that funds the channel.

The problem is not translation. It is trust. So I built the trust part.

What it does

TrueCopy connects to a YouTube channel, translates each video's title and description into the target languages, and then runs a deterministic gate over every translation before anything is written:

  • every URL in the source is present, byte for byte
  • every timestamp is present and still well-formed
  • every @handle, #hashtag and promo code is preserved
  • the title is at most 100 characters, the description at most 5,000

Any language that fails any rule is refused, and the report names the rule and the exact token. Only passing languages are published, with one videos.update call per video. Then TrueCopy reads the video back from YouTube with hl=<language> and shows what a viewer in that language actually sees. The proof comes from YouTube, not from my tool.

Two more things it does:

  • Audit existing translations. Point it at a channel and it runs the same gate over the localizations that are already published, with no LLM involved. Links rot, editors touch translations, older tools made mistakes. This finds them.
  • Gate playground. Paste any title and description, translate it, then edit the translation by hand, or press "break it for me", and re-check. No account needed. The gate is deterministic, so it names the same rule every time.

The tool makes no claim about translation quality. It makes a falsifiable claim about structural integrity and checks it.

How we built it

  • Backend: Java 25, Spring Boot 4. YouTube Data API v3 through Google's official Java client with an OAuth 2.0 web flow. Fetch-then-update so existing localizations are never wiped; snippet.defaultLanguage is set explicitly because the API rejects localizations without it. Runs execute asynchronously on virtual threads and are persisted as JSON.
  • Translation: Gemini through the REST API with a JSON response schema at temperature 0. The protected tokens are extracted first and pinned in the prompt. The translator is behind an interface; a Claude implementation is one property away.
  • The gate: seven rules in plain Java, no model in the loop, with a unit test per rule using hand-written bad translations.
  • Frontend: React, TypeScript, Vite, Tailwind, Framer Motion. Basu built the design system and the landing page; the workspace shows the pipeline, the gate report, a source-versus-translation diff with every protected token highlighted, and the live readback card.
  • Deploy: one Docker image serves the site and the API from the same origin. A public deployment runs with live writes disabled, so the judge can use the playground, dry runs, audits and the run history without being able to touch the channel.

Challenges we ran into

  • The free Gemini tier has a daily cap per model, not just a per-minute one. My retry logic burned an entire day's allowance on one model in an afternoon. The fix was to detect Google's PerDay quota id, never retry it, and fall back through a list of models automatically. This was the single thing most likely to break on demo day, which is why it got engineered rather than hoped over.
  • YouTube's consent screen. Testing-mode OAuth apps only admit listed test users, and the Data API has to be enabled per project. Both failures show the real reason in the app now instead of "channels.list failed".
  • Every description on my own channel was empty. The gate had nothing to protect until I wrote a real description with links and chapters. That is also why the audit mode exists: real channels have real translations to check.

Accomplishments that we're proud of

  • The refusal. Watching the gate reject a translation because one URL changed, and name it, is the moment the whole project makes sense.
  • The readback. YouTube returning the Spanish title is a stronger proof than anything the tool could print about itself.
  • It is safe to point at a real channel. Dry run by default, fetch-then-update, a live-write guard for public deployments, and a quota meter.

What we learned

  • Put the deterministic check after the model, not the human. A creator cannot review Japanese. A regex can.
  • Free-tier quotas are the real constraint on a solo build, and the honest answer is pacing plus fallback, not hoping.
  • Ship the narrow thing that visibly works. Three languages that verify beat eight that might.

What's next for TrueCopy

  • An echo rule, which is the one hole I found in my own gate. I attacked it with ten adversarial translations. It caught a link whose domain was extended into a lookalike, an https quietly downgraded to http, a timestamp buried inside a longer number, a handle whose case had changed, and a hashtag that had grown a suffix. The one thing it passes is a "translation" byte-identical to the source, because every protected token is trivially intact. That is the signature of a model echoing its input instead of translating, and the gate should refuse it when the target language differs from the source. It is a small rule and I left it out rather than change the gate hours before the deadline, which felt like the more honest engineering call than shipping an untested rule.
  • Caption tracks per language through captions.insert, same gate.
  • Generated per-language thumbnail files for YouTube's new localized-thumbnail slot (Studio only for now; not in the Data API).
  • A "what a viewer sees" preview for every language before publishing.

Known limits, stated plainly: YouTube only, because it is the one platform whose API accepts localized metadata. The Data API does not expose audio tracks, so target languages are an input, not detected from dubs. Setting defaultLanguage on a video that had none is a recorded side effect. Tested on my own channel only, with no outside creators yet.

Multi-tenant, with a read-only demo. Each visitor gets their own session, and anyone can connect their own YouTube channel: the OAuth client is published, so consent works for any Google account rather than a list of test users. Visitors who connect nothing land on my channel in read-only demo mode, so the workspace is usable immediately without signing in to anything. Demo sessions can audit, dry run and read back, but the publish path checks the session type and refuses them, independently of the deployment's live-write setting, so nobody can write to my channel through the demo. The one rough edge is Google's: because the app is unverified, consent shows a "Google hasn't verified this app" warning that you have to click through. Verification takes weeks and is a release step, not a feature.

One disclosure, because the demo depends on it. The German translation on the demo video is a fixture I published by hand with two faults in it: the shop link points at the wrong domain and a chapter timestamp was rewritten as prose. It is there so the audit has something real to catch, on a real channel, through the real API. Every other translation on that video was produced and published by TrueCopy, and the refusal you see is the actual gate running, not a scripted result.

The judging criteria, with a way to check each one

Functionality: does it actually work, reliably?

  • It runs against a real YouTube channel and writes real localizations. After every write it reads the video back from YouTube with hl=<language> and compares. The proof on screen is YouTube's response, not a log line from my code.
  • The gate has one unit test per rule, each using a hand-written bad translation: a rewritten URL, a timestamp turned into prose, a translated handle, a dropped hashtag, a changed promo code, an overlong title, an overlong description. 19 tests, green on GitHub Actions.
  • Reliability is engineered, not hoped for: dry run by default, fetch-then-update so existing localizations are never wiped, a quota meter against YouTube's 10,000 daily units, Gemini pacing with automatic fallback across models when a free-tier daily cap is hit, and a live-write guard for public deployments.
  • The three-step check at the top of this page takes about a minute and needs no account. Nothing there is canned: the audit runs the real gate over real published localizations, and the readback panel is YouTube answering a live API call.

Real-world usefulness: would a creator use this, does it save real effort?

  • The manual path today, per video, per language, in YouTube Studio: open the video, open Translations, add a language, paste a title, paste a description, save. Twenty videos in three languages is sixty forms, and nothing checks whether the affiliate link survived. TrueCopy does a channel in one run and refuses anything it cannot prove intact.
  • Demand is not hypothetical. ReTranslate charges from $20 a month for bulk title and description localization; TubeBuddy sells AutoTranslate on its top tier. Both gate on human review per language, which stops working the moment a creator cannot read the language. TrueCopy gates on a deterministic check, so it scales to Japanese for a creator who only reads English.
  • The timing is new. Since February 2026 every creator gets auto-dubbed audio. The metadata gap is now on millions of videos that did not have it a year ago.
  • Audit mode gives value to anyone who already has translations, from any tool or by hand, with no LLM call: it finds the rotted links and mangled timestamps that are live right now.
  • Tested on my own channel only. No outside creators have used it yet; that is the next step, not a claim.

Creativity: original, and a pain point not already well solved

  • Every localization tool I found translates. None of them refuse. The verification gate with a refusal path, naming the rule and the exact token, is the mechanism, and it is different in kind from a review step.
  • Auditing the localizations already published on a channel is not offered by any tool I found.
  • The proof comes from YouTube. TrueCopy does not just call the API and assume it worked; it reads the video back in the target language and asserts the returned title matches what was sent, inside the tool. A gate that scores its own output is grading its own homework.

Technical execution

Shape of the code. 55 Java classes and 15 TypeScript modules, no file doing two jobs. One pipeline, six stages, each its own unit: Generate, Protect, Verify, Refuse, Publish, Prove. The translator sits behind a Translator interface, so Gemini and Claude are two implementations selected by one property, and the gate depends on neither: seven pure rules over strings, no model, no network, no I/O. That is why it can be unit tested exhaustively and why it returns the same verdict every time.

Correctness at the API seam, which is where this class of tool actually breaks.

  • Fetch-then-update, never a blind update. A blind videos.update wipes every localization already on the video. This is the single most destructive mistake available in this API and it is designed out.
  • snippet.defaultLanguage is set explicitly, because the API rejects localizations without it with defaultLanguageNotSet.
  • The update payload is constructed fresh with exactly the parts named in the request. Echoing the fetched object back is rejected with unexpectedPart. I hit that bug on a live write and fixed it rather than working around it.
  • Readback retries with a delay, because YouTube's localizations are read-after-write eventually consistent and an immediate read returns the old title. Verifying too early would have produced false failures on camera.

Failure handling is engineered, not hoped for. The Gemini free tier enforces a per-minute rate and a per-model daily cap, and they need opposite responses: the first should be waited out, the second must never be retried. The client reads Google's quotaId, honours the server's own retryDelay for the first, and for the second advances to the next model in a configured list without burning an attempt. Dry run is the default, live writes sit behind an ALLOW_LIVE_RUNS guard that returns 403 on the public deployment, and every run is persisted as JSON so a crash loses nothing.

Quota economics were designed, not discovered. One videos.update carries every language for a video, so cost is 50 units per video and not 50 per language. Each readback is 1 unit. Enumeration walks the channel's uploads playlist at 1 unit instead of search.list at 100. The meter is on screen during the run.

Testing and delivery. 19 tests over three suites, one per gate rule with a hand-written bad translation as the fixture, plus token extraction and a context load. GitHub Actions builds the frontend and the backend on every push and publishes the test summary. The whole product ships as one multi-stage Docker image, Node build then Maven then a JRE runtime, serving the SPA and the API from a single origin with secrets read from the environment.

Built With

Share this project:

Updates

Submission history