A JSON to After Effects converter and a template-driven tool both start with a JSON file and end with a rendered video, but they put the design in different places. In a converter the JSON describes the video. In a template-driven setup like Templater, the After Effects project describes the video and the JSON only fills it in. Which one you want depends on a single question, and we will get to it quickly.
People who search for a converter are often trying to solve a pipeline problem. They have records in a database or an app, they need a video per record, and somebody has told them After Effects can do it. We build Templater, so we have an obvious interest in how this comparison ends. We will try to be fair about it anyway, because there are real jobs where a converter is the better fit, and we would rather you pick correctly than pick us.
What a converter does, and what a template does with the same file
The word converter is used loosely, so it helps to pin it down. Here, a converter means any script or tool that reads a JSON file and builds After Effects content from it. The file might list layers, positions, colors, durations and text. The tool walks through that list and creates the comp, adds the layers and sets the properties. If you change the file, you change the structure of the video. The JSON is a description of the whole composition, written as data instead of clicked together in a timeline.
A template-driven tool works the other way around. A designer builds the composition in After Effects first, with all the animation and timing done by hand. Then the designer marks which layers are dynamic. The JSON never mentions a layer’s position, its easing, or its font. It carries only the content that changes from one video to the next, such as a headline, a photo path, a hex color or a name. Our own description of the file Templater accepts is a plain text file containing a JSON object array. Each object plays the part of a spreadsheet row, and each key plays the part of a column header. One object becomes one version of the video.
That is the whole difference, and every practical consequence follows from it. So here is the question that sorts the two. When the next video is different from the last one, is it different in content or in structure? If the layout, animation and timing stay put and only the words and pictures change, you have a template problem. If the number of layers changes, the animation changes, or the scene order changes depending on the data, you have a structure problem. Structure problems are what converters exist for.
We should be honest that real projects sit on a spectrum. A product video where some items have a sale badge and some do not is mostly content, with one small structural switch. A video that shows three scenes for one customer and eleven for another is mostly structure. This article is written mainly for the first kind of reader. If you are in the second group, the next section is for you.
Where a converter is the right tool
A converter earns its place when the JSON really is the design. This is general practice, not something from our product documentation, so weigh it as one vendor’s honest opinion. If a developer is generating motion graphics from a data structure, such as a chart that must draw exactly the bars the data holds, then code that builds layers can express that more directly than any template. The video has no fixed shape to rig. There is nothing for a designer to polish by hand, because the shape comes from the data.
A converter is also a sensible choice for a one-off job. If you have a single file and a single deadline, writing a script to build the comp can be faster than rigging a template you will use once. The cost of a template is the setup. You pay that cost back over many versions. For one version, you never get the refund.
The third case is a team that has no motion designer and does have a developer. A developer is comfortable with code as the source of truth, and the output is allowed to look like generated graphics. If that describes you, a converter keeps everything in your repository, which is where your team already works.
Now the costs, because they are the reason most teams eventually move away from this approach for brand video. First, the design lives in code. When the marketing team says the headline should ease in more slowly, someone has to find that line in a script, change it and re-run it. A motion designer cannot open a script and nudge a curve with a mouse. Second, the output tends to look like the converter and not like the brand, because every visual decision has to be written down before it can be used. Hand-polished animation, the kind a designer builds by feel, is awkward to describe in a data file. Third, maintenance falls on whoever wrote the converter. When After Effects updates or the brand changes, that person is the single point of failure.
There is one more thing worth knowing about After Effects itself. It can import a JSON file as a footage item, and expressions can read values from it. Templater uses that for one feature. When you turn on the Import Templater data as JSON footage preference, it writes a file called templater-data.json containing the current job’s data, imports it into the project, and overwrites it for each job. You can then point an expression at one of the keys. Two limits come with it, and our documentation states both. Every value in that file arrives as a string, so an expression has to cast it into a number or an array before doing math. And the feature is described as experimental, because as of After Effects 15.1.1 a dialog can appear when the imported JSON changes structure, which can interrupt a batch. For that reason we recommend referencing a dynamic text layer’s Source Text property in expressions, which is the more stable route. This is a useful reminder that After Effects reads JSON as data to look at, not as instructions for building a project.
How the template route handles a JSON file in practice
Here is a concrete case. Picture a travel agency whose booking app can export a list of current deals as JSON. Each deal has a destination, a headline, a price line, a photo and a theme color. The agency wants a short video per deal for social posts. This is an illustration, not a customer of ours, and the keys below are invented for the example. Nothing in Templater requires these exact names.
[
{
"id": "lisbon-spring",
"destination": "Lisbon",
"headline": "Spring flights are open",
"photo": "lisbon.jpg",
"tint": "E07A3F",
"output": "social/lisbon-spring"
},
{
"id": "oslo-winter",
"destination": "Oslo",
"headline": "Aurora season, three nights",
"photo": "oslo.jpg",
"tint": "3F6FE0",
"output": "social/oslo-winter"
}
]A designer builds one composition. The destination, headline and photo are layers. Each of those layers gets a unique name that matches a key, so the text layer for the headline is named headline. Our documentation is specific about this step. You rename each dynamic layer yourself, even when the name it already has looks the same as the key, because a layer that has not been explicitly renamed may not be processed as dynamic. Avoid spaces in layer names. Then you apply the Templater Settings effect to each dynamic layer, once per layer. Applying it twice to the same layer produces unexpected results.
Four of the keys in that file have jobs of their own. Templater reserves a handful of names for its own use, and they are case-sensitive, so a stray capital letter matters. The id key lets you label each output. By default Templater identifies outputs by the position of the object in the array, which works until someone reorders the file. A real id survives that. The output key sets the file name for each render, and it can include a relative folder path, so social/lisbon-spring creates the file inside a social sub-folder of your destination. If a value in output and a value in id both exist, output wins for naming. One small tip from our docs saves a headache, which is to avoid a period in a custom output name, because it can cause an After Effects output error. The other reserved keys are target, which picks a composition, aep, which switches project files per record, and render-status, bot, module and render-settings, which matter once you automate. You can read more on the reserved names in our post on unique IDs and switching project files, and on naming in the post about custom output file names.
Now compare the two routes on the thing that always happens, which is that the data does not behave. Say the Oslo headline is twice as long as the Lisbon one. In a converter, the person who wrote it has to have anticipated that and coded a rule, such as shrinking the text or breaking the line. In Templater, the designer sets layout rules once while looking at the comp. When it updates a composition with your data, it adjusts dynamic layers relative to the composition that contains them and to their sibling layers, and layers you have attached or chained follow a text layer as it changes. Those rules apply to every row. Time stretching can fit footage of different lengths into a set period, at the cost of changing playback speed. You still have to check the result, because a rule cannot know that a headline is awkward in a particular language, but the check happens in a preview and not in a debugger.
Previewing is where the template route is hard to beat. Templater has a manual mode, where you step between jobs and watch the dynamic layers update with consecutive objects from the array, and a cycle mode that steps through a range automatically. It rereads the data source each time you preview and does not cache, so an edit to the file shows up on the next step. A tip from our documentation is to preview a small range at first, since a short range is faster. Cycle mode reads the source once before it starts, so rows you add while it cycles will not appear until you start again. That is the practical way to catch the Oslo problem before you render a batch.
Missing assets are the other thing that always happens. If a record points at a photo that is not there, Templater lets you choose what to do. It can ask you, let you find the file, skip the row, use a branded placeholder, or cancel the process. We recommend the branded placeholder for batches, because it keeps the run going while you fix the data. There is also a preference to treat empty cells and null values as faulty, and if you leave it off, an empty value makes the layer hold over the content from the previous row. That behavior surprises people, so check that setting before you trust a batch where some fields are blank.
Two housekeeping rules come with a JSON file. The file should be saved in UTF-8 so international characters come through intact. Templater supports right-to-left text through its text styling options, and our documentation advises using a font that is installed on your system and supports the languages in your dynamic text layers. That is a short list of things a template route gives you without writing a line of code. A converter can do all of it as well, if someone writes it.
Running it at volume, and where JSON lives after the first test
Rigging and previewing happen in the lowest edition. Rig maps your data to layers and previews them. Pro adds the buttons that batch render or batch replicate re-versioned compositions from your data. Bot adds automation, so Templater can check for new data and start renders without a person pressing anything, or take commands from the command line. If you want to try the whole thing first, the free trial contains all features in every edition, with a watermark added to the dynamic layers. The command line is available in the trial too.
Templater Editions
Three editions, each adding one capability
| Edition | What it adds | Trial watermark? |
|---|---|---|
| Rig | Maps data to layers and previews them | Yes, on dynamic layers |
| Pro | Batch render or batch replicate re-versioned compositions | Yes, on dynamic layers |
| Bot | Automation, command line control, checks for new data | Yes, on dynamic layers |
For a pipeline, the JSON usually stops being a file and becomes a feed. Templater can read JSON from a URL, and the setup is yours to build. The documentation says plainly that this requires knowledge of configuring web servers. You stand up a REST endpoint that returns a JSON array of objects, and the keys in those objects must match your dynamic layer names or the reserved keys. A framework such as Express for Node or Laravel for PHP is the quick way to do it. Our walkthrough of using a URL feed or JSON file as a data source goes through it step by step, and the post on data sources in general compares JSON with the sheet options.
There is one catch with a feed that a developer should know before building anything. The Bot normally tracks progress by writing a render-status value back to the data source, moving a row from ready to queued, then processing, then done, or to an error code such as ERR::MEDIA when it cannot find or import a media asset. With a URL feed the Bot cannot write that value back, because the feed belongs to your system. You register scripts on Templater’s events, such as Post Job and Post Batch, to update the status yourself, or the same row can render again the next time the Bot checks. This is easy to miss when moving from a file to a feed, so read the Bot documentation before the first live run.
If you would rather not run a web server for this, QUE is our answer. It is a web application for managing the data, and it is JSON-based. You can drag a JSON file into the QUE Dashboard as a batch import, as long as the file contains a single array of objects. Excel, CSV and TSV files import the same way. You pick which satellite, meaning a machine running After Effects with Templater, will process the jobs, and which autograf, meaning a rigged project, will use the data. Developers can use the QUE API instead and create jobs one at a time or in batches through its endpoints. If your question is really “how do I send JSON from my own app”, our post on inserting a batch of jobs into QUE covers the batch path, and the QUE page has the overview. For the broader walkthrough of the file-based route, start with how to drive After Effects videos from JSON data, which goes deeper on mapping than we have here.
A last practical point on the example. The travel agency can add a new deal by adding an object to the file or the feed. Nobody opens After Effects. The designer only returns when the look changes, and then the change happens once in the template and flows into every later render. That is the maintenance story in one sentence. In a converter, the designer’s change becomes a code change.
The bottom line
Pick a converter when the JSON is the design. That means the structure of each video depends on the data, the output can look generated, and a developer owns the whole thing. Pick a template-driven tool when a designer owns the look and the data only supplies content. That describes brand video, ad variations, and personalized or localized campaigns where the layout stays fixed.
If you are unsure, test by changing the data in your head. Swap in a longer headline, a missing photo and a record with one fewer field. If your solution has to be rewritten, you have a converter problem or a weak template. If it only needs a rule, you have a template problem and a template will serve you. Our Templater page lists the editions, and the trial lets you rig a real project with your own JSON before you decide anything.
These questions come up once you put the converter and template routes side by side.
Frequently Asked Questions
Is there a single JSON to After Effects converter that turns any JSON file into a finished video?
No, and the reason is that JSON does not say what a video should look like. A converter needs a file in a structure it understands, and someone has to define that structure and write the code that builds layers from it. After Effects itself imports JSON only as footage that expressions can read. If your goal is a video per record, the practical route is a rigged template where the JSON supplies only the content, so the design stays in After Effects.
What does Templater expect a JSON file to look like?
A plain text file containing an array of objects, saved in UTF-8. Each object becomes one version of the video, and each key matches a dynamic layer name or one of the reserved keys such as id, output, target or aep. Reserved names are case-sensitive. We recommend adding your own id to each object so outputs keep the same name even if the order of the array changes.
Can I use a live JSON feed from my own app instead of a file?
Yes. Templater can read JSON from a URL, but you build and host the endpoint yourself, and it must return an array of objects with keys that match your layers. The Bot cannot write render-status back to a feed, so you register scripts on Templater events such as Post Job and Post Batch to update the status. Without that, a row marked ready can render again on the next check.
Does a template handle data that is longer, shorter or missing?
Mostly yes, with limits. Layout rules adjust dynamic layers relative to the composition and to sibling layers, and time stretching can fit footage of different lengths into a set period. For missing footage you choose a behavior, and a branded placeholder keeps a batch moving. You still need to preview. A rule cannot judge whether a long headline reads well in a particular language, so step through a range in preview mode before rendering.
Which Templater edition do I need to batch render from JSON?
Rig maps data to layers and previews the result. Pro adds batch rendering and replication from your data source. Bot adds automation, including checking a data source for new rows, plus command line control. The free trial includes all features in every edition, with a watermark on dynamic layers, so you can test the full flow with your own file before buying.
Can I send JSON from my own app without running a web server?
Yes, through QUE. You can import a JSON file containing a single array of objects in the QUE Dashboard, choosing the satellite and autograf that will process it. Developers can use the QUE API to create jobs one at a time or in batches. QUE is JSON-based and built to work with Templater, so it saves you from building and securing your own feed.
