Translate video ads at scale without losing brand

Search "translate video ads" and every tool you find is a dubbing tool. Upload a finished video, pick target languages, and the voiceover comes back transcribed, translated and re-synthesised, sometimes with the presenter's lips adjusted to match. For a talking-head explainer, that genuinely solves the problem.

For a paid social ad it solves less than half of it, because most of what an ad says is not in the audio. It is in the pixels: the headline in the first second, the offer, the price, the feature callouts, the end-card call to action, the legal line. Dub the sound and all of that stays in the source language, on screen, in front of a viewer who is quite possibly watching with the sound off anyway.

This tutorial covers the other half. You will re-render the ad itself per language: same template, same motion design, translated on-screen copy, brand terminology protected by enforced rules rather than a translator's memory, and a human approving each market before anything spends money. At the end you will see how Nubu's assistant sets the whole fan-out up from a plain-language brief, which turns the manual steps into a review exercise.

Dubbing tools translate the audio. Your ad is mostly pixels#

Credit where it is due: the dubbing and lip-sync tools are good at their job. Voice cloning has reached the point where a dubbed presenter is watchable, and for content built around a person talking to camera you should use one.

Paid social creative is a different animal, for three reasons.

Most of the copy is on screen. A product ad carries its message as animated text: a hook headline, a price or an offer, benefit callouts timed to the cut, a closing call to action. The voiceover, when there is one, supports the text rather than replacing it.

A large share of feed viewing happens with the sound off. The industry has spent a decade designing ads that work muted, which is precisely why the message migrated into the pixels. Translating the one channel many viewers never hear, and leaving the channel they all read untouched, is the wrong way round.

The text is burned into the render. By the time a video is an MP4, the headline is not a string any more. It is pixels with motion blur, tracking curves and a gradient behind it.

That last point is where audio-first tools hit a wall. The workaround some offer is patching: detect the burned-in text, mask it, overlay a translated string in an approximate font. On a static frame it can pass. On motion-designed type it cannot: the per-character animation is gone, the kerning is wrong, the mask shimmers on camera moves, and every market's ad ends up looking like a fansub of the original. Brand teams notice, and so do viewers.

The honest fix has always existed: go back to the master project, swap the text, re-render. Nobody does it at scale by hand because ten languages times three formats times two versions is a production schedule, not a task. That is the part worth automating, and it is a rendering problem, not an audio problem.

What proper ad localisation needs#

Before the walk-through, set the bar. A localised ad is only shippable when four things hold at once.

1. The design survives. Same template, same timing, same type system. The German version is the German version of the same ad, not a lookalike rebuilt in a hurry.
2. Brand language is enforced, not requested. Product names that never translate. Words the legal team has banned. The claim that is approved in the UK and prohibited in France. If those live in a briefing document, they will be missed eventually. They need to ride every translation request as binding rules.
3. A human signs off per market. Machine translation is a strong draft, and a draft is what it should be treated as. Someone who owns the market reads each creative before it goes anywhere near an ad account.
4. The cost is knowable and never paid twice. You should see what a fan-out will cost before running it, and rebuilding an unchanged campaign should cost nothing.

None of these are things a dubbing pass can give you, because they are properties of the creative pipeline, not of the finished file. In Nubu, localisation is part of the flow: the same graph that produces your ad in one language produces it in every language you add, through one translation step, under one set of brand rules, with review built in.

The walk-through below builds this by hand so you can see each part working. It assumes a campaign with a video template and source copy written in English. If your copy lives in a spreadsheet, the CSV route feeds exactly the same pipeline.

Step 1: write the glossary before you translate anything#

The reflex is to start with the flow. Start with the glossary instead, because every translation request that runs before your rules exist is a request that ran without them.

A brand glossary in Nubu is organised per market, and each market carries its own rule set:

• Tone of voice, up to 500 characters describing how the brand speaks in that market. Formal or informal address, energy, the things this market's copy never does.
• Do-not-translate terms: product names, feature names, the tagline you keep in English everywhere. These pass through every translation untouched.
• Forbidden words: terms that must never appear in that market's copy, whatever the model would naturally reach for.
• Approved phrases: the phrasings the brand prefers, so the model chooses your words when a choice exists.
• Approved translation pairs: exact source-to-translation pairs that are reused verbatim. When "Free returns" must always render as one specific sentence in German, the pair goes here, and every ad gets that exact sentence rather than a fresh improvisation per request.
• Claims, each held in one of three states: approved, prohibited, or needs qualifier. A claim marked needs qualifier carries its qualifier line with it, so the claim and its legal footnote travel as a unit.

Two practical details save real pain later.

First, aliases. Markets and languages in Nubu are free-text values, so one flow might say "UK" where another says "United Kingdom". Market names in the glossary carry aliases, and matching is case-insensitive, so add every spelling your team actually uses and they all resolve to the same rule set.

Second, visible gaps. When a market value matches no glossary market, nothing fails silently and nothing guesses: the translate node labels that route "runs without rules". You can see exactly which markets are travelling without protection before you build, and fix the alias or add the market.

Write the glossary with the market owners, not for them. The tone field and the claims list are exactly the knowledge that lives in local marketers' heads, and this is the place it stops being tribal. The full field reference is in the glossaries doc.

Step 2: wire the flow: one translate node, every route#

Now the flow. The shape you are building:

• A Market node with one row per market. Say UK, Germany, France and Mexico.
• A Language node beneath it, wired so each market opens the languages it actually runs: English for the UK, German for Germany, French for France, Spanish for Mexico.
• Your source copy as text nodes, gated through that market and language chain.
• One AI Translate node between the copy and the template.

The gating is what makes everything downstream automatic. Because the source copy travels through the market and language chain, every route arrives at the translate node already carrying its own market and its own language. The node reads the target from the pipe at build time. There is nothing to type on the node itself: no target-language dropdown, no per-language settings, and that is deliberate, because configuration you retype per language is configuration that drifts.

Which leads to the rule that surprises people who have built this elsewhere: one translate node serves every route. Never one node per language. Germany's route arrives carrying German and picks up Germany's glossary rules; Mexico's arrives carrying Spanish and Mexico's rules; the same node handles both, and every market you add later, without being touched. If you find yourself duplicating translate nodes, the copy is not gated through the chain yet.

One node also serves every text. Several texts pipe into the same node as separate lanes: the headline is one lane, the ad copy is another, the call to action a third. Each lane's output carries that lane's translation to its own destination, so headlines and descriptions share one node without ever mixing. One node, every route, every text.

Here is the whole mechanism live. Drag a route and watch each lane pick up its market and language as the copy flows through:

On the real node, each lane shows its resolved routes as chips, so you can read exactly what will run before anything does:

At this point people usually ask which languages are supported. Nubu ships no language list. Markets and languages are values you type into the flow, so the range is whatever your own OpenAI, Anthropic or Gemini model handles. The node's mechanics, handles and lane behaviour are covered in the AI nodes doc.

Step 3: mark the languages you already write natively#

Your source copy is English, which means the UK route needs no translation at all. Tell the node so.

The translate node's Original Language setting takes the languages whose copy is already written natively. Every route carrying one of those languages passes straight through untranslated: no AI request is made and nothing is spent. Those routes also leave the node's translation list, so what remains on the node is exactly the set of translations that will really run.

This matters more than it looks. Plenty of teams write two or three languages in-house and only need the machine for the rest. Mark English and Spanish as original languages and the UK and Mexico routes carry your copywriters' lines untouched, while Germany and France translate under the glossary. You get one flow for the whole campaign without paying to translate copy you already wrote, and without the model rephrasing lines a human signed off.

Step 4: preview every route, then build#

Before spending anything, read the flow back to yourself. The node's chips list every route per lane. The "runs without rules" label flags any market the glossary does not cover. And you can preview any single route's translation directly from the node, so you can spot-check the German headline against the glossary before committing to the full set.

When you press Build, Nubu counts the distinct AI requests the flow needs and shows you the number before anything runs. Our example is small: six copy fields times three translated routes is eighteen requests, and the UK route costs nothing because it passes through as original language.

About those costs. Nubu does not sell AI credits and adds no margin: you connect your own OpenAI, Anthropic or Gemini API key, and the provider bills you directly at its raw prices. Eighteen short translation requests on a current model is small change, and you can see the shape of it before confirming. The full reasoning behind the bring-your-own-keys model is in its own piece.

You never pay for the same translation twice. Rebuild the campaign without changing the copy and nothing is re-spent: every request has already been answered. Change one headline and only that headline's routes translate again. Original Language routes are always free: no request is ever made for them.

If you want to see the request count on your own campaign rather than mine, create a workspace and run a two-market fan-out first: the build dialog shows the number before anything spends.

Step 5: review per market, then re-render#

The build produces one creative per route, each carrying its own translated copy, and every creative goes through review before it renders. This is the human gate from the localisation bar in section two, and it is per creative, which in a fan-out means per market: the person who owns Germany reads the German creative, checks the claim wording and the tone, and approves or rejects that creative without touching France's.

Approved creatives render. This is where the re-rendering half of the story pays off: the render runs your real After Effects template per language, so the on-screen text changes and everything else survives exactly as designed. The type animates the way the motion designer built it, in every language, because it is the same project rendering different data. How a creative goes from flow to finished file is covered in building a creative, and if the template carries multiple sizes, every language renders in every size from the one template.

From the renders grid, delivery is a choice per destination. Push to Meta or Google and everything arrives as paused ads: nothing goes live until someone switches it on in the ad platform. Or export a ZIP with a manifest that carries every creative's copy and UTMs alongside the files, for the markets that traffic their own ads. Either way, the copy that ships is the copy that was approved, per market, by a person.

Or describe the brief and let the assistant wire it#

Everything above is the manual route, and it is worth doing once because afterwards you can read any fan-out at a glance. But you do not have to build it by hand, because this is exactly the kind of structure Nubu's assistant is good at.

Describe the brief in plain language: the campaign, the markets, the languages, which languages you write natively, which template. For the flow this tutorial just built, the whole brief is one message:

Set up the autumn campaign flow for UK, Germany, France and Mexico, each in its own language. We write English and Spanish natively, so only German and French need translating. Use the same template as the spring campaign and the Fernhaven glossary.

The assistant drafts the flow: the market and language nodes, the translate node wired with lanes, the glossary attached. What comes back is a proposal card showing the expected creative count and the matrix with the real copy per route, so you are reviewing actual German headlines against actual French ones before anything exists.

The card is not a sketch. Every flow the assistant offers has already been test-built, passing the same checks a real Build runs, so a flow that would fail validation is never offered in the first place. You approve the card, the flow exists, and from there the pipeline is the one you just walked through: preview, build, per-market review, render.

The same chat serves the per-market read-back. Before Germany's owner signs off, ask:

Check the German copy in this flow against the glossary.

The whole-flow copy check reads every written value in the flow, hand-written translations included, checks each one against its route's market rules, and flags forbidden words, prohibited claims and missing qualifiers by name, with a coverage count so a partial pass can never look like a complete one.

What the assistant never does is approve. It proposes; the approval of the flow is yours, and the approval of each market's creative still belongs to the person who owns that market. That split, AI proposes and humans approve, is the whole design, and it is what makes the speed safe to use.

Honest limits#

A few things this system does not claim, so you can plan around reality.

Constraints are enforceable. Quality is not a score. The glossary makes hard rules hard: do-not-translate terms pass through, approved pairs are reused verbatim, prohibited claims stay out, qualifiers travel with their claims. What no tool can honestly promise is that a translation is good, and Nubu does not grade its own output. That is what the per-market review gate is for, and it is a design decision, not an apology: native speakers approve, and the system makes their review fast rather than pretending to replace it.

Dubbing tools still have their half. If your ads carry a voiceover that matters, a dubbing pass on the audio and a Nubu fan-out on the creative are complementary, not competing. This piece exists because the on-screen half was the unserved one.

AI features are Business and above. The translate node, the glossary enforcement and the assistant sit on Business plans and up; see pricing for the current lines.

You bring your own model key. AI translation runs on your organisation's own OpenAI, Anthropic or Gemini key. That is a feature, because the provider bills you at raw prices with no margin, but it does mean connecting a key is part of setup. And it sets the only real boundary on language coverage: any language your connected model can write.

Start with two markets#

Do not begin with the full matrix. Pick one template, two markets, one of them your native language. Write the glossary for the translated market with whoever owns it: tone, the do-not-translate list, the two or three claims that actually carry legal weight. Wire the chain, or describe it to the assistant and review the card. Build, read the translated creative next to the original, and let the market owner reject it if it deserves rejecting. That loop, run once, teaches you more than any feature list.

Then widen. Every language you add is another lane through the same node, under the same glossary. The flow does not get harder at ten routes than it was at two; the review gate scales because each market only ever reviews its own work; and because unchanged copy is never re-translated, iteration stops costing you translation money at all.

Your ads already say the right things in one language. Create a workspace and let them say the same things, on screen and on brand, in every market you run.