When you promote a property to the Essential Properties panel, Templater can drive it from a data source, but only on a pre-comp layer that is an instance of your primary composition. The primary comp’s own values stay put and become the defaults. That one sentence decides how you should build a rig, so it is worth taking apart slowly.
This article is for the motion designer who is about to build a template and wants to know what to promote, where the promoted values end up, and what the data can and cannot touch. We will stick to what Dataclay’s support documentation states. Where it says nothing, which includes the question of how many levels deep you can go, we will say so and give you a quick test rather than a guess.
What promotion exposes, and where Templater actually writes
Adobe built the Essential Properties panel so designers can pull the properties they use most into one place. You open a composition, mark it as a primary composition, and drag properties into the panel. Those properties become the handles that anyone using the comp as a nested layer can adjust without opening the comp itself.
Templater’s Dynamic Essential Properties feature, available from Templater 3.5, uses exactly those handles. The documentation puts the key point plainly. This method does not change the essential property values of the primary composition itself. Templater updates essential property values on layer instances, the pre-comp layers, of the primary composition.
Picture the structure the documentation describes. There is a target composition, which the documentation’s example names , and the double braces mark it as the project’s default target composition for Templater processing. Inside it sits a layer, and that layer is an instance of another comp, the primary comp. The values you set in the primary comp’s Essential Properties panel are the defaults for the instance. The instance then has its own set of essential properties, and those are the ones a data source can control.
In practice this means you have two places a value can live. The first is the primary comp, where you design the look and set the default for every promoted property. The second is the instance layer, where Templater applies data for a specific job. A designer building a rig should think of the primary comp as the rest state and the instance as the place the data lands.
Here is an example, and it is ours, not the documentation’s. Say you are building a lower third for a news package. The design lives in a comp called LowerThird_Master. You promote four things to the Essential Properties panel: the name text, the title text, the fill color of the bar, and a logo media layer. You then drop LowerThird_Master into your comp and name the resulting layer lt_main. In the master, you set the defaults to a placeholder name, a placeholder title, your brand color and a generic logo. When Templater runs a job, it keeps those defaults and changes only what the row asks it to change on lt_main.
The rest-state design matters because of a rule the documentation spells out. Each time the comp is reversioned, Templater reloads all the default essential property key and value pairs you set in your primary comp. Then it changes only the pairs found in the data for that job. If a property key is not in your data for that job, or its value is null or undefined, Templater uses the default. That has a quiet consequence for how you design. You do not need a column for every promoted property. A row that only carries a name and a title will give you a lower third with the default color and the default logo. Defaults are what you ship when the data says nothing, so choose them as carefully as you choose the look.
Naming things so the data can find them
Promotion is half of the job. The other half is giving the data a way to point at the right layer and the right property. The documentation is specific about three things, and each one is a place rigs go wrong.
First, the layer name. When you drag a composition into another to make a pre-comp layer, After Effects gives the layer the same name as the source comp by default. You must explicitly name the layer so Templater recognizes it as dynamic and so your data source can refer to it. The documentation recommends giving it an entirely new name, which helps you tell the source composition from its instance, and it says you should not use spaces in layer names. So LowerThird_Master becomes lt_main, not “LowerThird_Master” with a number on the end, and not “lower third”.
Second, the Templater Settings effect. The pre-comp layer must have the Templater Settings effect applied to it. That is how Templater knows the layer is dynamic. A designer who builds the whole rig, names everything cleanly, promotes every property, and forgets to apply the effect to the instance will get no changes and no obvious reason why.
Third, the property names. The name of each property key in your data source must be an exact match for the name of the property in the Essential Properties panel. This includes groups. If a property sits inside a group in the panel, the group name is part of the key. In a spreadsheet, the documentation shows a color property named Subheader Fill that lives inside a group called Colors as a column header of the form layer name@[Colors > Subheader Fill]. In a JSON data source, the same property sits inside a nested object, under a key for the group name.
The practical advice for a rig builder is to name your promoted properties and groups for the person who will write the data sheet. A property called “Text 1” in a group called “Group 1” is a bug waiting to happen, because the person writing column headers will have to guess at what you meant, and the documentation says an inexact match does not work. Names like “Subheader Fill” in a group called “Colors” are easier to get right and easier to read in a header.
One more detail on the key syntax, because it affects how you hand a rig to a developer. There are two ways to address properties. You can use a single element named layer name@egp that holds an object of properties, or you can use individual keys of the form layer name@[property name]. You can mix them. If the same property shows up in both, the individual key takes precedence. A sensible pattern for a rig is to put the properties that change in every job into the egp object and use individual keys for the occasional override.
What the data can set, and the three places the feature runs out
The documentation lists the data types that Essential Properties accept from a data source. A color is entered in the panel as an RGB array like [51,255,172], and in the data source as a hex code like #FFFFFF. A numeric property takes a numeric value. A boolean takes true for on and false for off. A grouped property follows the nesting shown above. And a media asset property takes a path, local or remote.
If the type of data in your data source does not match what is expected, Templater skips that property key and writes an error to its log file. For a mismatched media asset, Templater respects the preference you have set for that scenario. That means a typo in a color value does not stop a render. It leaves the default in place and leaves a line in the log. For the rig builder, this is the argument for testing with the log open, since a wrong value produces a default-looking result rather than a visible failure.
Now the limits, which are better learned before the rig is built than after.
The first limit is media. For a media layer to be controllable, the documentation says to drag the entire media layer into the Essential Properties panel in the primary comp. That works for images and similar footage. The documentation also says it does not recommend reversioning video assets this way, because After Effects does not support Time Sculpting, audio files or videos with audio in video layers promoted to the Essential Properties panel. For video footage it recommends using the existing Templater method for versioning footage. So if your lower third has a looping background clip that changes per job, promote an image logo with this feature and handle video with a regular Templater dynamic footage layer.
The second limit is that this feature works on one layer at a time. The documentation compares it to the rest of Templater and states that reversioning this way may not be as dependable as the functionality Templater already offers. Its example is that Time Sculpting and similar features affect more than a single layer, so Templater cannot change those layers using this feature. It adds that power users may prefer the existing Templater methodology alone or combined with Dynamic Essential Properties. The honest summary for a designer is that Essential Properties are a good fit for pre-built templates and for properties you can name, and a poor fit when your design depends on Templater’s layout and timing logic across many layers.
The third limit is the one the title of this article asks about, and the answer is that the documentation does not state one. It does not say how many levels of nesting are supported. It does not say what happens if you promote a property in a comp that is itself a nested instance, and then promote that again from a comp above it. It does not describe flattening, and it does not describe properties disappearing. Every example it gives has the same shape. A primary comp with promoted properties, one instance of it inside the target comp, and a data source addressing that instance by layer name.
We are not going to state a depth limit, because a page that invented one would send you away from a rig that might work. We are also not going to promise that deeper structures work, because the documentation never shows one. What we can give you is a short test, and it is worth doing before you commit your design time to a structure.
A short depth test before you build the real rig
Build the smallest possible version of the nesting you intend to use. Make a primary comp with a single text layer and one promoted property, such as the text itself. Nest it once into a second comp and promote nothing there. Nest that second comp into your target comp. Name the outer layer with no spaces and apply the Templater Settings effect to it. Connect a one-row data source.
Now try the key the documentation shows, using the outer layer’s name followed by @[ and the property name. Run a preview and see whether the text changes. If it does, you have a working one-level case and you know your names are right. Then add one more level of nesting and repeat. At each step, change one thing only, and write down whether the value changed, whether the log shows an error, and what the Essential Properties panel looked like at that level.
The reason to test this way is that the failure modes are quiet. A wrong key does not crash. It leaves the default in place. Without the stepwise test you can spend an afternoon rewording a column header when the real issue is the structure, and the log is the thing that tells you which one it is.
Keep the test file. Keeping it gives your team a known-good reference, and it gives you somewhere to reproduce a problem later without dragging the production project into it.
Handing the rig to whoever writes the data
A rig is only finished when the person who feeds it can use it without calling you. For Essential Properties rigs, that means a short sheet of paper, or a tab in the spreadsheet, with a few things on it.
List the instance layer name exactly. List every promoted property by its exact name, with its group if it has one. List the data type for each, so they know a color is a hex code and a boolean is true or false. List the default for each, so they know what appears when the cell is empty. And say which properties are media, with a note on whether the path may be local or remote. The documentation says both are supported.
If you are working alongside a developer who drives your template from a data sheet or a JSON feed, they will care about a related point, which we cover in a separate piece on why values set on a nested pre-comp do not always behave the way people expect. For now, the thing to give them is the exact key syntax and a working example row.
Our blog post on Dynamic Essential Properties in Templater 3.5 shows the MoGRT use case that the feature was built to support. The spot check guide explains how to verify promoted property values across many jobs before a batch, which is worth doing since a wrong key fails quietly. If your design also needs timing that follows the text length, read about Time Sculpting and layout rules, because those are the Templater features the documentation says Essential Properties cannot reach. The Templater page has the rest.
The bottom line
Promote the properties you want data to change. Name the instance layer, apply the Templater Settings effect to it, and keep the names free of spaces. Set defaults in the primary comp that you are happy to ship, because the data only overrides what it mentions. Use Essential Properties for text, colors, numbers, booleans and images, and use the regular Templater methods for video footage and for anything that depends on timing across layers.
And on depth, we can say only this. The documentation shows one level of instancing and states no limit. Test your own structure in a small file first, with the log open, and trust that over any article, ours included.
Here are the questions designers ask us most about this feature.
Frequently Asked Questions
Does Templater change the values in my primary composition?
No. The documentation says Dynamic Essential Properties does not change the essential property values of the primary composition itself. Templater updates the values on the layer instance, the pre-comp layer, that sits in another composition. The values you set in the primary comp become that instance’s defaults, and each job changes only the properties found in the data.
How many levels of nesting can Essential Properties handle?
The documentation does not state a limit, and it does not show an example deeper than one primary comp with an instance inside the target comp. Build the smallest version of your intended structure, add one level at a time, and check the log at each step. Do not rely on a number from anyone, including us, that you have not measured in your own project.
Do I need a column for every promoted property?
No. Each time the composition is reversioned, Templater reloads the defaults from the primary comp and changes only the properties found in the data. If a property key is missing from a row, or its value is null or undefined, the default is used. This is why the defaults you set in the primary comp are worth setting carefully.
What happens if I enter the wrong type of value?
Templater skips that property key and writes an error to its log file. For a media asset that does not match, it follows the preference you have set for that situation. The render does not necessarily fail, so check the log when a value looks like it did not apply. Colors take a hex code in the data source, booleans take true or false, and numbers take numeric values.
Can I swap video clips with Essential Properties?
The documentation does not recommend it. It says After Effects does not support Time Sculpting, audio files or videos with audio in video layers promoted to the Essential Properties panel, and it recommends the existing Templater method for versioning video footage. Image and similar media layers can be promoted by dragging the entire media layer into the panel.
Why does my layer name matter so much?
The data source finds the instance by its layer name, in the form layer name@egp or layer name@[property name]. After Effects names a new pre-comp layer after its source comp by default, so you must rename it. The documentation recommends an entirely new name and says to avoid spaces. The pre-comp layer also needs the Templater Settings effect applied.
