Opens in a new tab
Guide

Templater API: What Exists

Published November 13, 2026

There is no single “Templater API.” There are four separate things people mean when they type those words, and picking the wrong one costs you an afternoon. One is a scripting object that lives inside After Effects. One is a web API that belongs to Que. One is a command line for Bot. And one is an API you build yourself, so that Templater can read from it. This page is the map.

We wrote it for the person who has a pipeline problem and a half-formed picture of where code fits. Maybe you are a developer whose web app has to ask for a video. Maybe you are a producer who wants a script to clean up a spreadsheet before it hits the layout. Either way, the first question is the same: where does your code run, and who is calling whom?

The four things people call the Templater API

Start with the fact that Templater is an After Effects plugin. It does its work inside After Effects, on a machine that has After Effects installed. Anything that touches the template, the layers, or the render happens there. Everything else is a way of getting data and instructions to that machine, or of reacting to what it does.

The ExtendScript API. This is the one our support site actually titles “Templater ExtendScript API Reference.” It is a set of methods on one object, called the D object, that gives your script access to Templater’s internal memory. In real code the object name starts with a dollar sign, which is a quirk of the way ExtendScript names things, so we spell it out here as the D object and write the methods as D.job.get and so on. Your script runs inside After Effects, and Templater runs it when a particular event is broadcast. It sees the batch of jobs, the current job, the layers Templater is about to update, and the output Templater has worked out. It exists to change or inspect things in the middle of a run.

The Que API. Que is a datastore with an API. You call it over the web, from anywhere, with a key. It does not touch After Effects directly. What it does is hold the data for your jobs and the list of machines that will render them. Your code puts jobs in. A machine running Templater Bot takes them out, renders them, and writes the status back. The official reference is the Que API documentation, and our Que page explains the product around it.

The command line. Templater Bot has a command-line interface. Our own copy says you can use the command line to push data in to create new renders, and that Bot can check a data source periodically for incoming data to kick off new ones. That makes it the right door when a process on the same machine, or a scheduler you control, needs to start a run without anyone clicking. A file called templater-options.json holds the options, and it has a bot object in it. The ExtendScript reference ties back to that file, because the Bot name you set there is the value that D.bot_id returns.

A feed you build. This one runs in the opposite direction. Instead of sending jobs to Templater, you stand up a small web service and let Templater read from it. Our support pages describe how to set up a URL feed as a data source. You build a REST API on your own server, with endpoints that return JSON object arrays, and the property keys must match your dynamic layer names or the reserved keys. It takes knowledge of configuring web servers, and any technology stack will do.

Put those four side by side and a pattern shows up. Two of them push work toward Templater, the Que API and the command line. One is Templater reaching out for work, the URL feed. And one is code that runs inside the render itself, the ExtendScript API. The confusion comes from mixing up the direction. A developer reads “API,” assumes a REST endpoint that renders a video on request, and goes looking for it. Templater does not work like that. The Que reference documents no endpoint that renders a video while you wait. Jobs go into a queue and a machine with After Effects works through them.

What each one actually exposes

Let’s be concrete about what you can touch in each, because the list is the honest answer to the question “what exists.”

Inside After Effects, the D object. The reference lists these, and nothing beyond them.

  • D.range returns the start and end ordinal positions of the rows Templater retrieved for the current batch. The reference notes that with Bot enabled, those values may not represent the range actually processed.
  • D.batch has three methods. D.batch.get returns the array of job objects, or one property across all of them if you pass a key. D.batch.set runs a function over every job. D.batch.file returns the file holding the batch details.
  • D.job has D.job.get and D.job.set, plus D.job.file. Get reads a value from the current job by its key. Set writes a new value into it. Both key and value are required for set.
  • D.harvest returns arrays of layers that carry the Templater Settings effect, sorted into text, footage, solid, comp and adjustment layers.
  • D.update.layout and D.update.timeline invoke Templater’s automatic spatial layout and temporal arrangement. The reference says scripts using them are likely to be registered with the Before Update or After Update event.
  • D.task returns PREVIEW, RENDER or REPLICATE, so a script knows which task Templater was invoked with.
  • D.target describes the composition Templater is targeting, or returns false if no target is specified.
  • D.output returns the name, loc, file, template and module for the current output.
  • D.event returns the last broadcast event, from a list that runs from bot_pre_data through bot_post_rndr, plus bot_on_enable and bot_on_shutdown.
  • D.bot_id returns the ID or name of the Bot that ran the script.
  • D.log writes to templater.log and templater.err, with msg, err, location and file methods.
  • D.download, D.footage.layer, D.footage.source and D.footage.item cover remote footage and are marked as available in Templater 3.4 or later.

Notice what is absent. The reference lists no method that starts a render from the script, none that adds rows to your spreadsheet, and nothing that talks to Que. The D object is for shaping a run that is already happening. That is a useful thing to be clear about before you write any code. If you want to start a run, you want one of the other doors.

The reference also carries a warning worth repeating. Some D object methods can return unexpected values or errors depending on which event your script is registered to, and our own page gives the Bot Enabled event as an example. Before you build on a method, check it under the event you plan to use. Our post on using ExtendScript with events and job details goes through that side of it, and the explainer on event scripts covers when a script is worth writing at all.

Over the web, the Que API. Every endpoint in the reference sits under the path api/v1 on the host. It groups into the four Que components, and the reference organizes it that way.

  • Satellites are the machines that process jobs. The reference documents create, authorize, revoke, update, retrieve all, and delete. Registering a satellite and authorizing it are two separate steps. The authorization returns a satellite token, and the reference says that token is set to expire five years from creation.
  • Autografs are the JSON representations of your After Effects projects. The reference documents create, update, retrieve one, retrieve all, and delete. In practice, a designer creates the autograf from inside Templater, using the Autograf Setup dialog, and the reference calls that the best practice for updates too.
  • Campaigns hold your jobs and give them default values. The reference documents create, update, retrieve all, retrieve statistics, delete, and a purge that removes every job inside a campaign. Deleting a campaign and purging one both require your Organization Key in a request header named org-secret-key, which is a deliberate speed bump.
  • Jobs are the rows. The reference documents create, retrieve jobs in a campaign with filters and paging, retrieve jobs assigned to a satellite, import a batch, update, update as a satellite, and delete.

Two details about jobs matter to a developer. The first is that a job is a bag of key-value pairs. If you come from spreadsheets, our own docs suggest thinking of a job as a row, with the keys as the column headers. The keys map to the dynamic layers in your autograf, and you can also use Templater’s reserved names, such as output for the output file name and target for the target composition. The second is that new jobs arrive with a render-status of ready unless you say otherwise. If you leave out the aep or bot keys, Que fills them in from the campaign’s default autograf and satellite.

Authentication is a bearer token. You copy your API key from the Account page in the Que Dashboard and send it in the authorization header. Keep it out of code you share. If you think the key is compromised, generate a new one and use that in your app’s environment.

If you also want the step-by-step, we already wrote it. The getting started guide for keys, endpoints and your first job walks the first call, and the post on sending render jobs to Que with the API follows a job from request to finished file. For the campaign side, there is a walkthrough of running a campaign from code. We will not repeat them here. This page is about choosing.

Which one do you mean? A decision map by situation

Here is a way to choose that starts from your situation and not from the product names.

Your code lives outside After Effects and needs a video made. Use the Que API. A web or mobile app is the plain example. A customer fills in a form, your server posts a job, and a render machine picks it up. The shape of the thing is a queue. Your app does not wait for a file. It creates a job, later reads the job’s status, and then fetches the output. If you need many at once, the reference has a batch import, which takes the campaign ID and an array of job objects.

You want no code at all. Look at the Zapier integration before you write anything. Dataclay built a first-party Que app on Zapier’s platform. The only thing you need to connect it is your Que API key. Our support page says it is the only first-party Que integration for now, and that other automation tools should be able to connect through the API directly. If you already live in another provider’s tools, the API documentation is the way in.

You have a script that needs to clean, fix or add to the data in the middle of a run. Use the ExtendScript API. The documented example is a good one. Say your sheet has a column called title, and some values run long. A short function can loop over every job in the batch and cut any title longer than ten characters, then add three dots. You hand that function to D.batch.set and it applies to every job. Or say a column holds a first name, and you want to override one value for the current job. D.job.set does that with a key and a value. The script never leaves After Effects, and it runs at the event you register it for.

You need to know where each output landed. The ExtendScript API again. D.output gives you the name, the folder, the full file path, and the render settings template and output module Templater used. A script registered after output can pass that path to the next step in your pipeline. That next step can be a shell script, and we have a separate post on shell scripts with Templater events.

A process on the render machine has to start a run on its own. The command line. A scheduler or another program on that machine can start Bot and push data in. One real caveat from our own troubleshooting notes: when you use the command line to monitor a data source and After Effects is not running in the foreground, you can see an error about being unable to find a Window Constructor. The fix is to add a -ui argument when launching Bot. If you plan to run unattended, test that case on day one and not after the launch.

Your data already sits in your own database. You have two honest paths. Push the data to Que with the API, or expose it as a URL feed that Templater reads. The feed path puts the work on your side, because you build the REST endpoints and shape the JSON. There is a trade-off our support page spells out. With a URL feed, Bot cannot update the render-status key, since the data source belongs to your system. So you register custom scripts at the right events to update render-status yourself, or you risk re-rendering rows that are still marked ready. With Que, status is part of the job record and the pipeline updates it for you. If your goal is the least code to maintain, that difference alone may decide it.

A worked example: one agency, two doors

Picture a small agency that makes personalized videos for a client’s customers. Orders come in through the client’s web form. That is the Que API’s territory, so the agency’s developer writes a small service that posts a job for each submission. The job carries a headline and a subtitle, an output name, and a target composition if the template needs one. The campaign supplies the default autograf and satellite, so the developer does not have to send them on every request.

Then the agency finds a data problem. Customers type their names in all sorts of ways, and a few headlines run far too long for the layout. The developer could fix this in the service before posting. But the designer would rather fix it where the layout lives. So the designer writes one ExtendScript that registers to run before each job, reads the headline with D.job.get, shortens it, and writes it back with D.job.set. Same pipeline, two doors, each used for what it is good at. The web API moves data in. The script protects the layout.

That split is the one we would suggest to a team starting out. Use the Que API for transport and the ExtendScript API for judgment. Do not try to make the script do the transport, because it cannot, and do not try to make the web API do the layout work, because it has no access to the layers.

What does not exist, and who should skip all of this

A map is only trustworthy if it marks the dead ends. Here are the ones we know of from our own documentation.

The Que API reference documents no endpoint that renders a video synchronously and returns the file in the same response. Jobs are queued, and the render happens on a satellite machine running After Effects with Templater. Plan your user experience around waiting. If a customer clicks a button, show them a pending state and read the job’s status.

The ExtendScript reference lists no method that creates a job in Que, and the Que reference lists no endpoint that edits an After Effects layer. The two APIs do not overlap. Each side of your system has its own.

The official reference lists the job statuses its filters accept as ready, queued, processing and done. Our own help material adds canceled and error codes such as ERR::MEDIA for asset problems and ERR::AFXHOST for After Effects errors. If you build a dashboard on the status field, handle every one of those, and not only the happy path. Our post on Que job states explains what each one means and what to do next.

Older help pages use older names. They say templates where the API reference now says autografs, they call the setup dialog the Project Manifest, and one of them uses _satelliteId where the reference says bot. When the two disagree, trust the API reference. If you copy an older example, check the names before you debug anything else.

We should also be plain about who should not bother. If you render a few dozen versions of a template from a spreadsheet, with a person at the keyboard, you need none of this. Link the sheet, preview, and render. Our Templater page shows what that looks like. The APIs earn their keep when the requests come from software and not from a person, when the volume grows past what a person can supervise, or when a rule has to be applied to every job. If none of those describes you, skip the code and keep your afternoon.

One last limit. Everything above is a reference, and a reference tells you what exists, not what is wise. We have documented calls, keys and events. We have not benchmarked any of them against your hardware, and we are not going to guess at speeds. Test with a small campaign on your own satellite before you promise anyone a turnaround.

The short version

When someone says “the Templater API,” ask where their code runs. Inside After Effects, it is the ExtendScript API and the D object. Outside it, sending work in, it is the Que API or the command line. Reading from your own system, it is a URL feed you build. For some teams the best answer is the first two together, one for transport and one for judgment. And if no software is in the picture yet, you do not need an API at all.

We covered a lot of ground up there. These are the questions people ask us when they are choosing between the doors.

Frequently Asked Questions

Does Templater have a REST API I can call to render a video on demand?

The REST API belongs to Que, not to Templater itself. You post a job to Que, and a machine running After Effects with Templater Bot takes jobs that have a render-status of ready and renders them. The render does not happen inside your request. Your app should create the job, then read its status later. If you need a response with the finished file in the same call, that is not how the system is built.

What is the D object, and why do you not write its full name?

The D object is the entry point to Templater’s ExtendScript API. Through it your script can read and change the batch of jobs, the current job, the layers Templater harvests, and the output it devises. In real code its name starts with a dollar sign. We spell it as the D object on this page so it stays free of that symbol. You will see the full name in our support site’s reference.

Can an ExtendScript start a render or send a job to Que?

No. The documented D object methods read and shape a run that is already happening. You can inspect the task, the target composition, the output, and the event, and you can change job values. Starting runs and creating jobs belongs to the Que API or the command line. If you want script logic and automatic starts together, register a script for the events you care about and let Que or the command line start the work.

Which job values can I send through the Que API?

A job is a set of key-value pairs, much like a spreadsheet row. The keys map to your autograf’s dynamic layers, so a headline key fills a headline text layer. You can also use Templater’s reserved names, for example output to name the file and target to set the composition. If you do not send aep or bot, Que uses the campaign’s default autograf and satellite. The render-status starts as ready unless you override it.

How do I get my API key, and how careful should I be with it?

Log in to the Que Dashboard, click your avatar, open the Account page, and generate or copy your API token. Send it as a bearer token in the authorization header. Treat it like a password. Do not post it or share it. If you suspect it leaked, generate a new one and update your app’s environment. Deleting a campaign or purging its jobs also needs your Organization Key in a separate header.

Is there a no-code way to connect Que to other apps?

Yes. Dataclay built a first-party Que app for Zapier. You connect it with your Que API key, and Zaps can then move data and media outputs in and out of Que without code. Our support page says it is the only first-party Que integration for now. If you prefer another automation provider, you can connect to the Que API directly by following that provider’s guide for custom APIs.

Should I push data to Que or let Templater read a URL feed from my server?

Push to Que when you want status tracking handled for you, since status lives on the job record. Choose a URL feed when you would rather keep the data on your own server and are comfortable building a REST endpoint that returns JSON object arrays. With a feed, Bot cannot update the render-status key, so you register your own scripts at the right events to avoid re-rendering rows that are still marked ready.

Leave the first comment

Sign up

Stay up to date with Datclay's newsletter. We won't spam your inbox.

Newsletter Signup
Name
Name
First
Last

By submitting your email, you agree to our Terms and Privacy Policy. You can opt out at any time.