Manually re-exporting versions in DaVinci Resolve works: you lock the edit, duplicate a timeline per variation, swap the endcard by hand, set each as its own render job, name the files, and Render All. It scales linearly and risks wrong-endcard mistakes. Recutly builds the endcard × cut × ratio matrix in one pass, names every file, and outputs Resolve XMLs you re-import.
Why you can't just queue versions from one timeline
The trap most editors hit first: open the Deliver page, queue three render jobs from the same timeline, and Render All. Resolve does not snapshot each job when you add it. It renders the current state of the timeline for every queued job. As Larry Jordan put it, "Though you exported three movies, they all have the content of the current version of the timeline... Resolve always looks to the current version." This is triple-confirmed across Larry Jordan, the Blackmagic Design forum, and tutorials, and it's a real difference from Final Cut Pro, which copies a temp version per job.
So "make versions" in Resolve always means separate timelines, not separate render jobs on one timeline.
The native manual method (it works)
Here's the dependable in-app workflow, step by step:
- Lock your edit so you stop changing the source.
- Duplicate the timeline (or copy all clips into a fresh blank timeline) for each version.
- Swap the endcard: delete the tail endcard clip, drag the alternate in, fix its duration.
- Set the aspect ratio per version (change Timeline Resolution + Transform, or use an Adjustment Clip).
- Add each timeline to the render queue as its own job.
- Name each output in the Deliver page File settings (Custom Name supports %metadata variables and User Presets).
- Render All. Multiple timelines batch in one session.
This is solid. The cost is that it's O(N) hand-work: every endcard, cut length, and ratio is another duplicate, another manual swap, another rename. Three endcards across three cut lengths across three ratios is 27 timelines to build and label by hand. There's also a quiet hazard. A duplicated timeline references the same compound/nested clip, so editing it in one version can silently change others unless you fully decouple by copying clips into a fresh timeline. And nothing stops you from dragging the wrong endcard onto the wrong cut.
Where Recutly fits
Recutly is a browser tool aimed at exactly that matrix. You export your finished edit as an FCP7 XML timeline and upload the timeline. Your footage never leaves your machine. Recutly crosses your endings × cut durations × aspect ratios into every delivery version, pairs the right ending with the right cut (the foolproofing step), names each file to your convention, and outputs Resolve timeline files (FCP7 XML). You re-import the XMLs into Resolve, media relinks by filename, and you render with your own settings.
Be honest about the roundtrip: Recutly outputs timeline files that carry your cuts and reference your endcard media. It does not rebuild a fully graded, titled, effects-laden master. FCP7 XML reliably carries cut points, clip references, and timing, but strips effects, transitions, speed ramps, Fusion titles, and graphics. The XML's frame rate must match your project timeline fps exactly or import fails, and you may need to relink media (Conform Options / Relink Selected Clips) if paths differ. It runs in free DaVinci Resolve because the roundtrip is plain XML, not a Studio-only feature.
On aspect ratios, Recutly sets up the ratio and canvas per version. Creative reframing, meaning repositioning each shot so the subject stays in frame, stays in Resolve. (Smart Reframe with auto subject-tracking is DaVinci Resolve Studio, paid only.) Recutly is not an AI auto-crop tool and doesn't claim to be.
Side-by-side comparison
| Approach | Endcard swap | Per-platform ratios | Naming | Foolproofs wrong cut | Resolve-native | Price |
|---|---|---|---|---|---|---|
| Duplicate timelines (manual) | Manual, per version | Manual per timeline | Manual / Deliver presets | No | Yes | Free |
| Render queue (one timeline) | N/A, renders current state | N/A | Deliver File settings | No | Yes | Free |
| Python scripting API | Cannot, no cut/split in API | Scriptable canvas | Scriptable | Partial (logic only) | Yes | Free |
| Generic batch tools (e.g. Wondershare) | No (renders, not edits) | Resize, not reframe | Often templated | No | No | Paid |
| Recutly | Automated swap + pairing | Sets ratio/canvas per version | Auto, to convention | Yes | Browser → Resolve XML | Free / $19 / $39 |
A note on two rows. The Python API can automate the render queue and duplicate timelines, which genuinely helps batching, but it cannot edit a timeline (no cut, split, or razor), so it can't perform the endcard swap itself. Even power users do that part by hand. Generic batch encoders re-encode a finished file into sizes; they resize, they don't reframe, and they don't touch your edit or pair endcards.
Which should you use
If you ship one or two versions occasionally, the manual duplicate-timeline method is fine. There's no reason to add a tool. The case for Recutly is volume and consistency: when the same edit goes out across several endcards, cut lengths, and platform ratios on a schedule, the manual matrix becomes a long stretch of duplicating, swapping, and renaming, with real odds of shipping the wrong endcard on the wrong cut. Recutly turns that into one pass that builds, pairs, and names the whole set, then hands Resolve back clean XMLs.
Recutly is Free for up to 5 versions per export, Pro at $19/mo for unlimited, and Studio at $39/mo. See pricing or the Studio tier for details.
FAQ
Can DaVinci Resolve export multiple versions of one timeline at once?
Yes, but not by queuing several render jobs from the same timeline. If you do that, Resolve renders the current state of the timeline for every job, not the version you queued. The reliable native method is to make a separate timeline per variation, add each as its own render job, name them in the Deliver page, and Render All.
What is the best alternative to duplicating timelines in DaVinci Resolve?
For a few one-off versions, duplicating timelines manually is fine. When you ship the same edit across multiple endcards, cut lengths, and aspect ratios, the duplicate-and-rename work scales linearly and invites wrong-endcard errors. Recutly builds that full matrix in one pass, names every file, and outputs Resolve XML timelines you re-import and render.
Does Recutly render the video for me?
No. Recutly takes your exported FCP7 XML timeline and outputs new Resolve timeline files (also FCP7 XML), one per version, named and paired correctly. Your footage never leaves your machine. You re-import the XMLs into Resolve, relink media by filename, and render with your own settings. The timeline fps must match your project.
Can I script this with the Resolve Python API instead?
Partly. The Resolve scripting API can automate the render queue and duplicate timelines, which helps with batching. But it cannot edit timelines. There is no cut, split, or razor in the API, so it cannot perform the endcard swap itself. You still do that part by hand. Recutly handles the swap and naming for you.
How much does Recutly cost?
Recutly has a Free tier that allows up to 5 versions per export, Pro at $19/mo for unlimited versions, and Studio at $39/mo. It runs in a browser and works with free DaVinci Resolve, since the timeline roundtrip uses FCP7 XML rather than any Studio-only feature. See recutly.com/pricing for current details.
