---
title: "DaVinci Resolve plugin"
description: "Bring an episode's cut into DaVinci Resolve as a timeline, and send your render back as the next version of an edit."
url: https://www.filmsquare.ai/docs/plugins/resolve/
lang: en
section: plugins
updated: 2026-11-16
---

# DaVinci Resolve plugin

The Filmsquare plugin for DaVinci Resolve brings the cut of an episode into Resolve as a timeline: every shot in
board order playing its pick, with the trims from **Edit → Cut**. When you have cut it, you render it and send it
back as the next version of a named edit. The open notes of the version before go along, and you see how many are
open with a link to **Review**.

The plugin is in beta. Nothing in it changes the cut in Filmsquare: the hub stays the source, and what comes back is
a render.

## What you need

| | Scripts menu | Command line |
| --- | --- | --- |
| Resolve Studio 18.5 or newer | Yes | Yes |
| Free Resolve 18.5 to 21.0 | Yes | Yes |
| Free Resolve 21.1 or newer | No | Yes |
| Python | 3.10 or newer | 3.10 or newer |

Resolve 21.1 moved Python scripting to Studio. In free Resolve 21.1 and later the script does not show in the
**Workspace → Scripts** menu, so you use the command line instead: it does the same work outside Resolve, and you
import the timeline and render yourself.

You also need a personal key: in Filmsquare open **Settings → Claude**, choose **Use a personal key instead**, then
**Create a personal key**. The key works as you, with your role, in that workspace. Copy it when it is shown: you
will not see it again. You can paste the whole command Filmsquare shows; the plugin takes the key out of it.

## Install

1. Download `resolve.zip` and unpack it. You need two of its files: `Filmsquare.py` and `filmsquare_resolve.pyz`.
2. Copy both files into the Resolve scripts folder for all pages:
   - Windows: `%APPDATA%\Blackmagic Design\DaVinci Resolve\Support\Fusion\Scripts\Utility`
   - macOS: `~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Utility`
   - Linux: `~/.local/share/DaVinciResolve/Fusion/Scripts/Utility`
3. Restart Resolve. **Workspace → Scripts → Filmsquare** opens the plugin.

For the command line you only need `filmsquare_resolve.pyz`; keep it anywhere.

## Updates

When you open the window, the plugin looks for a newer version, at most once a day. When there is one, the window
shows `Version 0.3.0 is ready.` with **Update**. **Update** downloads the new version, checks it against the
fingerprint published with it, and puts the new files in place of the old ones in the scripts folder. Then close the
Filmsquare window and open it again. **Update** waits while an import, a render or a retake is running.

On the command line:

```bash
python filmsquare_resolve.pyz update
```

If the plugin cannot write to the scripts folder (the one for all users, for example), **Update** becomes
**Download**: unpack the new `resolve.zip` and copy the two files in, as at install.

A self-hosted studio that keeps its own copy of the plugin publishes `resolve.json` next to its `resolve.zip` and
points the plugin at it with `FILMSQUARE_UPDATE_URL`, or with `"update_url"` in `resolve-update.json` next to
`resolve.json`.

## Bring the cut into Resolve

In the Scripts menu window:

1. Enter the server, the address you open the studio on in your browser (`https://app.filmsquare.ai`), and your key, and choose **Sign in**. The window then carries the name of that studio.
2. Pick the **Production** and the **Episode**.
3. Choose **Import cut**.

The plugin downloads the picks into `Filmsquare/Resolve` in your home folder and imports the cut as a timeline in the
open project, named after the episode (`EP01 cut`). A shot with nothing picked yet becomes a gap of its length. A
still holds for its hold time.

Every open note on the cut becomes a marker on the timeline: at its timecode when it has one, else on the shot's
first frame. The marker holds the author, the note and a link to the episode in **Review → Player**. A note on the
whole episode sits on the first frame. Notes on the same frame share one marker. Resolved notes are left out.

On the command line:

```bash
python filmsquare_resolve.pyz login
python filmsquare_resolve.pyz pull
```

`pull` asks for the production and episode, and writes the media and an `.otio` file with the notes as markers. In
Resolve choose **File → Import → Timeline** and pick that file.

## Newer picks and the selected shot

The window has two tabs.

**Cut** holds the import, the render and the newer picks. When someone sets a newer pick in Filmsquare after you
imported, the tab shows a count (`Cut · 2`) and lists the shots. Choose **Use picks** and each newer pick lands on the
same clip, in the same place and at the same length; the old take stays in Resolve's Take Selector, so you can switch back there. A pick that is shorter than your trim is left unticked, with the reason.

**Shot** follows the clip you select on the timeline. It shows the shot's takes and a balance in the header:

- **Retake** makes a new take of the shot, **More** runs a tool on it, such as an upscale to 4K. The price is shown in
  credits and in euros before you confirm, and you can close the window while it makes the take.
- **Use take** puts a ready take on the same clip; the old take stays in the Take Selector, so you can switch back.
- The shot's open notes sit below, each with **Go to** (moves the playhead), **Reply**, **Resolve** and **Fix this note**.
  **Fix this note** makes a retake that starts from the note. When it is ready, **Use take** puts it on the clip and
  fills in the reply; nothing is sent until you choose **Send reply**.

With too few credits, **Retake** is off and **Top up** opens Filmsquare in your browser. A viewer key has no Retake or
More.

## Send a version back

In the Scripts menu window, pick an **Edit** of the episode (or **New edit…**) and choose **Render and send**. The
plugin renders the current timeline to one H.264 file (MP4, or MOV where Resolve offers no MP4), uploads it and adds it as the next version of that edit.

On the command line, render in the **Deliver** page first, then:

```bash
python filmsquare_resolve.pyz push "EP01 cut.mp4"
```

`push` asks for the edit, or makes a new one. Files above 64 MB go up in parts, up to 5 GB. The first time you send a
file, Filmsquare asks you once to state that you have the rights to it.

After sending you see the version number and the open notes it carries, and **Open in Review** opens the version in
**Review → Player**, where the crew watches it and leaves notes on timecode. See
[notes and review](https://www.filmsquare.ai/docs/working-together/notes-and-review/) and [the cut](https://www.filmsquare.ai/docs/working-together/the-cut/).

## Known limits

- The window needs Resolve Studio. Free Resolve 21.1 and newer has no script window, so use the command line.
- Markers go one way, from the hub to the timeline. Markers you add in Resolve are not sent back.
- The two tabs were tested against the hub, not yet on a real Resolve.
- If a Resolve build has no tabs, the window shows everything in one column.
- Without a script timer, the window does not update by itself: choose **Refresh**.
- **Update** was tested outside Resolve, not yet on a real Resolve.

## Where your key is kept

The key is stored for you alone, outside any Resolve project:

- Windows: `%APPDATA%\Filmsquare\resolve.json`
- macOS: `~/Library/Application Support/Filmsquare/resolve.json`
- Linux: `~/.config/filmsquare/resolve.json`

It is only sent to the server you signed in to, over https (plain http only to a server on your own computer). **Sign out** (or `python filmsquare_resolve.pyz logout`)
removes it from this computer. To stop the key everywhere, disconnect it under **Settings → Claude**.
