Use case · Performance creative

Turn a winning ad into localized caption variants — fast enough to test

API-driven caption variants. Same hook, every market. Per-minute billing

Your winning creative is decaying in its home market while every other market sees nothing. ZapCap is the caption-rendering and translation API that spins a proven hook into localized variants from a single source clip, so the testing cycle keeps moving instead of waiting on an editor.

Spin up localized variantsIntegration guide
One winner → many variants · translateTo · webhook delivery
The problemArchitectureBackend codeState machineLaunch checklistBuild vs buyProofFAQ
The problem

A winning concept should not stall in localization

Performance creative lives or dies on iteration speed. You found the hook that converts — but turning it into testable variants per market means editor tickets, translation turnaround, and re-renders. By the time the variants land, the auction has moved.

  • Editor bottleneck — every variant queued behind a human in an NLE.
  • Translation lag — agency turnaround measured in days, not test cycles.
  • Hook consistency — the proven caption styling must survive the localization.
  • Variant sprawl — one winner becomes dozens of cuts to track and label.
  • Creative fatigue — the home-market winner decays while other markets wait.
  • Attribution mapping — each rendered variant tied back to an ad set.
Reference architecture

Where ZapCap sits in your creative-testing loop

Drop the API behind your creative-ops tooling. A winning source clip goes in; localized caption variants come back, labelled and ready to push into ad managers.

Your creative ops
Winning source creative
Markets to expand into
Source clip in your CDN
Your backend
Variant generator job
Holds ZAPCAP_API_KEY (server-only)
/webhooks/zapcap handler
ZapCap
POST /videos
Variant per market · translateTo
Localized renderUrl
Keep the winning styling locked: reuse the same templateId across variants so you test the message and the market, not the caption design.
Backend integration

One winner in, a variant per market out

Upload the winning clip once, then fire a render task per market with translateTo and a fixed caption preset. Each finished variant arrives via webhook, ready to label and push.

WEBHOOK PAYLOAD
{
  "eventId":   "evt_8kQ2...",
  "taskId":    "tsk_2hP4...",
  "event":     "render.completed",
  "renderUrl": "https://cdn.zapcap.../variant-es.mp4"
}
  • Map taskId → ad set / market when you create the task.
  • Verify the x-signature header before fetching renderUrl.
  • Dedupe webhook deliveries on eventId.
1// Turn one winning creative into localized variants
2const KEY = process.env.ZAPCAP_KEY;
3const ZAP = (path, body) =>
4 fetch(`https://api.zapcap.ai${path}`, {
5 method: 'POST',
6 headers: { 'x-api-key': KEY, 'Content-Type': 'application/json' },
7 body: JSON.stringify(body),
8 }).then(r => r.json());
9 
10const PRESET = "<TEMPLATE_UUID>"; // from GET /templates — your proven caption style
11const MARKETS = ['es', 'de', 'pt', 'zh']; // language codes, e.g. zh (not zh-CN)
12 
13export async function spinVariants(winnerUrl) {
14 const video = await ZAP('/videos/url', { url: winnerUrl });
15 
16 for (const lang of MARKETS) {
17 const task = await ZAP(`/videos/${video.id}/task`, {
18 templateId: PRESET,
19 translateTo: lang,
20 // emphasise the hook words the winner relied on
21 renderOptions: { subsOptions: { emphasizeKeywords: true } },
22 notification: {
23 type: 'webhook',
24 notificationsFor: ['render'],
25 recipient: 'https://growth.example.com/hooks/zapcap',
26 },
27 });
28 // tie the variant back to an ad set for attribution
29 await db.variants.create({ id: task.taskId, market: lang, status: 'processing' });
30 }
31}
State machine

Lifecycle of a variant render

Each variant is an independent task. Track them so creative ops sees the test batch fill in and can push winners the moment they land.

pending
transcribing
transcriptionCompleted
rendering
completed
In your tool
Show a variant batch board — "ES ready, DE rendering, PT queued" — so the team can launch each cut as soon as it completes.
On webhook
Pull the renderUrl, tag the variant with its market and source winner, and hand it to your ad-manager push.
On failure
Re-run only the failed variant; the rest of the test batch is unaffected.
Launch checklist

Before your first variant batch

A short list to keep variant generation fast and attributable. Creative ops, styling, and tracking in one place.

Talk to integrationsRead API docs
  • Lock the winning caption preset One templateId reused across variants so you test market, not design.
  • Keyword emphasis on Set subsOptions.emphasizeKeywords so the proven hook still pops per language.
  • Variant ↔ ad-set mapping Store taskId against the ad set so attribution survives the render.
  • Market list driven from config Add a market and the next batch picks it up automatically.
  • Webhook signature verified Check x-signature on every payload; dedupe on eventId.
  • Credit-balance check before a batch A variant batch is many renders — confirm balance before firing.
  • Auto-push or review gate Decide whether finished variants go live or wait for a human OK.
Build vs buy

The variant pipeline, honestly

Build it yourself

In-house variant generator

  • 1ASR + translation wiring — vendors, retries, terminology control.
  • 2Caption styling engine — reproduce the winning look per language.
  • 3Keyword emphasis logic — keep the hook prominent across scripts.
  • 4Render workers — ffmpeg / libass, autoscaling for test bursts.
  • 5Variant tracking — one winner, many labelled cuts, attribution.
  • 6Output storage — pre-signed URLs, expiry, cleanup.
  • 7Billing meter — per-minute counters across batches.
Use ZapCap

Variants as a primitive

  • 1POST /videos — upload the winner once.
  • 2translateTo per task — a localized variant per market.
  • 3Webhook handler — verify, label, push.
When ZapCap isn't the right answer: if you need to generate net-new creative concepts or assemble videos from data-driven templates, a broader video automation API (Creatomate, Shotstack, Bannerbear) likely fits better. See our honest alternatives comparisons.
Customer · Anonymized

A growth team wired the ZapCap API into their creative-ops tooling and now spins a proven winner into localized variants without an editor in the loop

Finding the winner is still the hard part — but turning it into testable variants per market is now an API call instead of an editor ticket, so the testing cycle keeps pace with creative decay.

Read case study
1 winner
Source clip per batch
per market
One localized variant each
no editor
In the variant loop
per-minute
Billing passes through cleanly

For performance marketers

Pick one templateId from GET /templates as your locked caption preset and reuse it on every task. The styling — font, colour, animation, placement — stays identical while translateTo changes the language, so you are testing the market and the message rather than the caption design.

Related

Build the rest of the creative pipeline

E-commerce video localization

Localize product video ads at scale from one source clip.

Read more

TikTok Shop video localization

9:16 safe-zone-aware caption variants for cross-border social commerce.

Read more

Multilingual subtitle rendering

The script-layout layer behind localized variants across many languages.

Read more

Animated captions API

The animation and keyword-emphasis behind a high-converting hook.

Read more

Video captioning API

The core capability — workflow, code, and output modes.

Read more

vs Submagic

When an end-user editor beats an API for your team.

Read more

Case study · Performance creative

How a growth team spins winners into localized variants via API.

Read more

Keep the testing cycle moving

Backend-only API, webhook-native, from $0.10/min base usage pricing. One winner in, a localized variant per market out — no editor in the loop.

Spin up localized variantsTalk to integrations