Yes, After Effects can import a JSON file, but it brings the file in as footage, not as a finished video. The values sit in your Project panel and an expression can read them. Nothing builds layers, swaps text or renders a version for you. If you came here hoping a JSON file would become a video on its own, the short answer is that it will not, and the rest of this page explains what does the work instead.
We make Templater, a plugin that lives in After Effects and turns data into videos, so we have spent a long time on exactly this question. People who ask it tend to be in one of two situations. One camp has a single JSON file and wants to read a few values inside a comp. The other camp has a feed from a developer, a CMS or a database, with dozens or hundreds of records, and wants each record to become its own render. Those are different problems, and the way you import the file depends on which one you have.
What After Effects does with a JSON file on its own
When you import a JSON file, After Effects treats it as a footage item. It shows up in the Project panel next to your images and clips, and you can drag it into a composition as a layer. That layer has no picture. What it carries is a set of properties, one for each value in the file, and those properties can be picked up with a pickwhip or referenced by name from an expression on any other layer.
That is the whole feature, and it is worth being precise about, because it is easy to expect more. This is general practice and not something unique to our tools: importing a JSON file does not create text layers from the keys, does not resize anything to fit the values and does not duplicate your comp once per record. It gives expressions a place to read from. Everything past that is up to you.
For one-off work that is often enough. Say you have a lower third with a name and a title, and a short JSON file that holds both. Import the file, add it to the comp, then write an expression on the text layer that reads the name from the JSON layer. Change the file, and the name changes. For a single graphic, that is a reasonable way to keep copy out of the timeline.
It gets uncomfortable when the same idea is stretched to a batch. A JSON file with many records has one structure, and an expression that reads from it reads from one place at a time. To render forty versions, you would have to change which record the expression points at, render, change it again, and repeat. You have moved the typing out of the text layer and into a counter, which is less typing, but it is still a person running a loop by hand. Nothing in the import step is a loop.
There are also two practical snags worth knowing before you build on this. The first is that a JSON file has to be valid before anything will read it, and a hand-edited file with a stray comma or an unquoted key fails in every tool. Run it through a validator before you import it. That is general practice, and it is a quick check that can save a lot of debugging. The second is that values do not always behave the way they look. A number in your file can arrive in an expression as text, so a price that reads fine on screen refuses to add up until you convert it.
Before You Build
What to check before a JSON-driven batch
- Validate the JSON file, a trailing comma or unquoted key fails in every tool
- Encode the file as UTF-8 so international characters come through intact
- Keep the file structure as an array of objects, one object per render job
- Rename each dynamic layer explicitly and match its name to a property key in your JSON
- Cast number values inside expressions, a number in your file can arrive as text
- Avoid periods in custom output names, since they can cause output errors in After Effects
Our own documentation is candid about a third snag. Dataclay’s support pages describe using JSON footage layers to feed expressions as an experimental feature. As of After Effects 15.1.1, a modal dialog appears and needs a click when an imported JSON footage item changes structure or data types. One click is nothing when you sit at the desk. In an unattended batch it is a stall, because there is nobody there to click it. We say so plainly because a setup that works while you watch it can stop when nobody is there.
A related caution from the same pages: previews that use this approach do not refresh on their own inside After Effects, because After Effects does not notice that the file changed on disk. Rendering should still pick up the right data, but the preview can show you yesterday’s values. If you ever wonder why the comp looks wrong while the render is right, that is the reason.
Three things people really want when they ask this
The search phrase is short, but the jobs behind it are not the same. It helps to name which one you are doing before you pick a method.
The first job is reading a few values inside one comp. You have a JSON file, you want to pull a headline or a color out of it, and you do not need a batch. Native import plus an expression handles this. You do not need any plugin for it, and we would not tell you to buy one. If this is you, import the file, drag it into the comp and write the expression. Keep the structure of the file flat, because deeply nested files make the expressions long and easy to break.
The second job is turning every record into its own video. Here you have an array of objects, one object per video, and you want a render for each. Native import cannot do this alone, because it has no concept of a record being a job. You need something that walks the array, applies each object to your template and sends each result to a render. That is what a data source in Templater is, and we get to it in the next section.
The third job is keeping JSON as the contract between a system and your motion team. A developer or a CMS produces the data and a motion designer owns the template. Both sides need to agree on the shape of the records and then leave each other alone. This is the situation where JSON earns its place, and where the real question stops being whether After Effects can open the file and becomes who owns the keys. We come back to this at the end, because it decides whether the project goes well.
Three Common Jobs
Which method fits what you actually need
| Job | What you have | Method to use |
|---|---|---|
| Read values in one comp | A JSON file and one comp needing a headline or color | Native import plus an expression, no plugin needed |
| One video per record | An array of objects, one object per video | A data source that treats each object as a render job |
| Team handoff via JSON | Developer on one side, motion designer on the other | Agree on key names before touching the template |
A concrete example makes the second and third jobs clear. Suppose a touring act’s marketing producer gets a JSON export from the ticketing team. It holds one object per show, and each object has a city, a venue, a date, a ticket link and a hex color for the poster. The producer has one After Effects template for a ten-second social clip and wants a version for every show, with the city in big type, the date underneath, and the color behind both. This is an invented scenario to illustrate the shape of the work, but it is how real requests arrive.
With native import alone, the producer could read the first show’s values into the template. For the second show, somebody would swap the record, check the text, render and name the file. By the twentieth show, someone has mistyped a venue and nobody has noticed. The data was fine. The manual loop around it was the weak part.
How Templater reads JSON, and what it asks of you
Templater approaches JSON from the other side. It does not make you import the file as footage and write expressions. It treats the JSON as a data source, in the same family as a Google Sheet or a tab-separated file. Dataclay’s data source documentation lists the options: a Que campaign, a native Google Sheets document, a tab-separated file exported from Excel, Numbers or Sheets, a plain text file containing JSON, or remote JSON data from a URL feed. In each case, every row of a spreadsheet or every object in a JSON array is one render job. Every column or property key is one dynamic element in the video template.
For our touring producer, that means the ticketing export becomes the data source with no reformatting. Each show object is a job. The keys in the objects are the names of the layers that should change.
That last sentence is the part that takes a little setup, so here is how it works. You give each dynamic layer in your template a name, something like city or ticketLink, and you apply the Templater Settings effect to it. The name must match a property key in your JSON. Our documentation says property keys in JSON objects are equivalent to column names in a spreadsheet, so anything you already know about naming columns carries over. A few details from the docs are worth repeating because they are easy to miss on a first setup. Layers have to be explicitly renamed after you create them, even if the source name happens to match. Layer names should not contain spaces. And the Templater Settings effect should be applied once per layer, not twice.
The file itself has two housekeeping rules. A plain text JSON file needs to be UTF-8 encoded, so that names and venues with accents or non-Latin characters come through intact. And the file should be an array of objects, because that is the shape Templater walks through.
If your data comes from a developer, you can skip the file and point Templater at a URL. This is the URL feed route. It takes a web server that returns a JSON object array from an endpoint, with keys that match your layer names or one of the reserved keys. You paste the address into the Data source field in the Templater panel, and that is the link. We should be straightforward about one limit. With a URL feed, Templater’s Bot cannot write the render-status value back to your data, because the feed lives on your server and not on the machine running the Bot. If you want to avoid re-rendering records that are already done, you register a script on the Post Job, Post Batch or On Bot Disable events to update the status yourself. That is a real piece of work for a developer, and we would rather you hear about it now than on a deadline. The full walkthrough is in our article on using a URL feed or JSON file as a Templater data source.
Templater Setup
How to link a JSON file to your template
-
Name each dynamic layerGive each dynamic layer in your template a name, something like city or ticketLink.
-
Apply Templater Settings effectApply the Templater Settings effect to each dynamic layer; the name must match a property key in your JSON.
-
Prepare the JSON fileThe file should be an array of objects and needs to be UTF-8 encoded so that names with accents or non-Latin characters come through intact.
-
Link the file as a data sourcePaste the file path or URL into the Data source field in the Templater panel; each object in the array is one render job.
-
Preview a few jobs, then renderPreview a few jobs before you render to confirm layer names match keys and values arrive correctly.
Naming outputs is the next thing you will want. Without any instruction, Templater identifies each output by its position in the array. That works, but position numbers are hard to match back to a show or a customer a month later. You have two ways to be explicit. Add an id key to each object, and Templater appends it to the job prefix and the target composition name. Or add an output key, which sets the file name directly and can even carry a relative path, so that outputs sort into subfolders. If both are present, output wins. One small tip from the documentation is to avoid periods in custom output names, since they can cause output errors in After Effects. For the tour example, an output value like berlin-2027-03-14 gives the producer a file name they can read without opening a spreadsheet. There is more on this in unique IDs and switching project files in a data source.
Not everything has to be text. The cells, or values, can hold text, URLs, image file paths or hex color values, which is why the producer’s hex color for the poster works as a plain value. Templater can also drive properties you have promoted to the Essential Properties panel, in versions 3.5 and later, by using JSON keys that include the exact property name. That change lands on the layer instance in the parent comp, so your master comp stays as you built it.
So what happens to the first job we described, reading values with expressions? Templater supports it, and it is worth knowing how it relates to the native import. In Templater 2.8.0 and later, there is a preference called Import Templater data as JSON footage. When it is on, Templater writes a file named templater-data.json with the data for a single job and imports it into the project. You drag that file into the comp, and expressions can pickwhip to its values. Two facts about that file matter. It only ever holds one object, the current job, and Templater overwrites it for each job. And every value in it arrives as a string, so a number needs to be cast with parseInt, parseFloat or parseNumber, and an array or object with eval.
Here is where we give you advice that may not serve a sale, but serves your project. We recommend against making that JSON footage route your main design. The experimental warning about the modal dialog applies to it. Our support documentation points to a steadier alternative, which is to map data to a dynamic text layer and have your expressions reference that layer’s Source Text property. The documentation calls the text layer the more stable option, and it does not rely on the JSON footage feature that the warnings above are about. Use the JSON footage layer when you want the convenience and can stand next to the machine. Use the text layer when the machine runs alone. We cover the pattern in using Templater data in After Effects expressions.
Last, a note on mixing sources. Templater pulls from a single data source per project, so you cannot combine a Google Sheet and a JSON file into one run. If your touring data lives in two places, merge it before it reaches Templater.
Data Source Choice
JSON file vs URL feed in Templater
- Who it suits
- JSON text filePerson exporting data and running batches at a desk
- URL feedDeveloper who wants data to stay live without exporting
- Export step required
- JSON text fileYes, export the array, then link the file
- URL feedNo, point Templater at the endpoint directly
- Bot writes render-status back
- JSON text fileYes
- URL feedCannot write render-status back to your data
Use a file when a person exports data and runs batches at a desk. Use a URL feed when a developer wants the data to stay live without exporting.
Which route to choose, and when to skip all of it
Here is the plain version, by job.
If you need a few values inside one comp, import the JSON as footage and write expressions. It costs you nothing, it is the thing After Effects already does, and a plugin adds nothing here. Keep the file small and flat, validate it, and expect that numbers may arrive as text.
If you need a video per record, use a data source. For a person running batches at a desk, a JSON text file is the simplest start. Export the array, link the file, preview a few jobs and render. For a developer who wants the data to stay live, a URL feed removes the exporting step, at the price of the render-status caveat above. For a team that adds jobs from other systems or wants a dashboard, Dataclay’s Que takes jobs into campaigns directly. In the Que Dashboard you can upload a single job as a JSON file, or use Batch Import with a JSON file that holds one array of objects. Excel files with a header row, and CSV or TSV files, work there too. You choose the satellite that will process the jobs and the autograf that will use the data, then upload. When you create a job from a file, the values in the file override the campaign defaults, which is useful to know when a record behaves differently from its neighbors. Our write-up on inserting a batch of jobs into Que from Excel, CSV or JSON goes through it step by step.
If the third job is yours, with a developer on one side and a motion designer on the other, spend your first hour on the keys, not on the template. Agree on the names, agree on which values are always present, and agree on how a missing value should look. Some batch problems are not rendering failures. They come from a key that was renamed on one side, a blank where text was expected or a number delivered as a word (general practice, not a measured rate). A field that goes wrong in one record can be anywhere in the file, which is why we wrote about field type mismatches between spreadsheet, JSON and URL feed sources. Read it before you hand a spec to a developer.
When should you skip all of this? If you are making a handful of versions a year, hand editing is fine and any tooling is overhead. If your JSON is a design file exported from another animation tool, that is a different category from data, and it is not what this page covers. And if the goal is video made by a generative model from a prompt, there is no template and no data source, so none of this applies. Our overview of data sources in Templater helps you judge whether your situation looks like a data-source job at all.
The bottom line is simple. After Effects can open a JSON file as footage, and for reading values into one comp that is enough. It cannot turn records into videos. For that, you need a data source that treats each object as a job, a template whose layer names match your keys and a clear agreement about what the keys mean. Get those three right and the format of the file hardly matters.
We covered a lot of ground up there. These are questions that come up for people with a JSON file and a template.
Frequently Asked Questions
Can After Effects import a JSON file directly?
Yes. After Effects brings a JSON file in as a footage item, and it appears in the Project panel. You can add it to a composition as a layer and read its values from expressions. It does not create text layers or compositions from the file. Think of it as a place where expressions can read data, not as a way to build a video from data. Dataclay’s documentation notes that this approach is experimental for batch work, since a dialog can appear when the imported file changes structure.
Why does my JSON file fail to import or read correctly?
A likely cause is invalid JSON. A trailing comma, an unquoted key or a missing bracket will stop any tool from reading the file, so run it through a validator first. This is general practice, not specific to our products. Another possible cause is the encoding. If you use the file as a Templater data source, it should be UTF-8, so that international characters come through. A third is expecting numbers to behave as numbers. Values can arrive as text and need converting inside an expression.
Can I make one video per record in a JSON file?
Yes, with a data source that treats each object in the array as one job. In Templater, each object is a render job, and each property key maps to a layer whose name matches. You name your layers to match the keys, apply the Templater Settings effect, link the file and preview a few jobs before you render. Native After Effects import alone does not do this, because it has no concept of one record per render.
Should I use a JSON file or a URL feed with Templater?
Use a file when a person exports data and runs batches at a desk. Use a URL feed when a developer wants the data to stay live without exporting. The feed needs a web server that returns a JSON object array. One limit to plan for is that the Templater Bot cannot update the render-status value in a feed, so you register scripts on the Post Job, Post Batch or On Bot Disable events to keep status current and avoid re-rendering finished records.
How do I name the output files when the data is JSON?
Add an id key or an output key to each object. The id is appended to the job prefix and the target composition name. The output key sets the file name directly, and it can include a relative path to sort files into subfolders. If both exist, output wins. If you add neither, Templater numbers outputs by their position in the array. Avoid periods in custom output names, since the documentation warns they can cause output errors.
Is it safe to read JSON footage in expressions during an unattended batch?
We would not rely on it. Dataclay’s documentation describes JSON footage in expressions as experimental, and as of After Effects 15.1.1 a dialog needs a click when an imported JSON footage item changes structure or data types. In an unattended batch, that can stall the run. The steadier option in our documentation is to map data to a dynamic text layer and reference that layer’s Source Text property from your expressions.
Can Que take a JSON file instead of Templater reading it?
Yes. In the Que Dashboard you can create a single job by selecting a JSON file, or import a batch with a JSON file that holds one array of objects. Excel files with a header row, and CSV or TSV files, are accepted as well. You pick the satellite that will process the jobs and the autograf that will use the data, then upload. Values in a job file override the campaign defaults, so a record can differ from its neighbors when it needs to.
