Your first Que API job needs three things to exist before the request will work: an authorized satellite, a template and a campaign. Get your API key from the Account page of the Que Dash, send it as a bearer token, and post a job to a campaign. The call itself is short. The setup in front of it is where most first attempts stall, so that is where this guide spends its time.
We wrote this for the developer who has been handed a Que account and told to “hook it up.” You know how to call a REST API. What you probably do not know yet is which parts of Que are meant to be created by your code and which are meant to be created by a motion designer sitting in After Effects. That split decides how you plan the work. If you want the bigger picture of what Que is before you write any code, our plain-language explainer, what Que is in Templater, is the better first read. If you are still weighing whether an API is the right route at all, our overview of the Que API and what it is used for covers the why. This page is the how.
What has to exist before your first request
Que is a chain of dependencies, and our help documentation spells the chain out. A job lives inside a campaign. A campaign needs a default template and a default satellite when you create it. A satellite is a machine, and a template is a rigged After Effects project. So before your code can create a single job, a real machine and a real project have to be registered with Que.
The documented workflow runs in this order. You get access to Que by buying a Que seat license on our website. You sign in to the Que Dash and collect your API key and your Organization Key from the Account page. Someone signs in to Que from Templater running inside After Effects. That same person creates a satellite from Templater’s QUE Configuration dialog. They rig a project and register it as a template through Templater’s Autograf Setup dialog. Only then does anyone create a campaign, and only then do jobs go in.
Notice how much of that happens inside Templater. This is the first thing to get straight on a new integration. The satellite and template endpoints exist, but our documentation says satellites are typically created and authorized by a person using Templater, and templates are typically inserted by an artist working in their authoring app. Your code usually takes over at the campaign and job level. Plan it that way and you avoid writing code for steps that a designer will do in two clicks anyway.
A practical consequence follows. Your first API job depends on another person’s work. Before you start, ask the designer for three things: confirmation that at least one satellite shows up in the Que Dash, confirmation that the template is registered, and the list of property names the template expects. That last one matters most. A job is just data, and the data only does something if its keys line up with what the rigged project was built to receive. If the designer named a text layer’s data “headline” and your code sends “title”, the job will be valid and the video will be wrong.
It helps to borrow the mental model our documentation offers for people who come from spreadsheets. Think of a Que job as one row. The job’s property keys are the column headers. The values are the cells in that row. If your team already made videos from a sheet, the designer can show you the header row they used, and that is very close to the shape of the JSON you will send.
Your plan also sets some limits worth knowing up front. Que comes in a Solo plan and a Team plan. Solo allows one user and two satellites. Team allows five users and five satellites. Both include unlimited jobs and campaigns, data encryption, dashboard access and API endpoint access. In other words, the API is not an add-on you have to buy separately. What is limited is how many machines can be attached at once, which matters more than it sounds when you get to rendering. For current pricing, see our Que page.
Getting your key and sending it the right way
Your API key lives in the Que Dash at que.dataclay.com. Click your avatar and choose Account from the menu. On the Account page you will see an API Token field. Click Generate next to it to create a new key, or click the copy icon to copy the key that already exists. The same page shows your Organization Key. You will not need that for most job calls, but the designer will need it when they add a satellite from Templater, so it is worth knowing where it sits.
Treat the key like a password, because to Que it effectively is one. Our documentation is direct about this. Never share it, post it or distribute it. If you think it has been exposed, generate a new one and put the new value into your application’s environment. Keep it out of source control and out of client-side code, since anything that ships to a browser can be read by whoever opens the developer tools.
Every request carries the key in an authorization header, with the value set to the word Bearer, a space and then your token. Our recommended way to manage this in an API development tool is to store the key in an environment variable, for example one named access_token, and reference it in the header as Bearer . You can paste the raw token into each request instead. It works. The cost shows up the day you regenerate the key, because every saved request with a pasted token breaks until you update each one by hand. With a variable, you change the value in one place and every request picks it up.
The same reasoning applies in production code. Read the token from configuration, not from a constant in the file. Regenerating a key is the documented response to a leak, and you want that to be a two-minute job rather than a hunt through the codebase. If more than one service talks to Que, list them somewhere, because a fresh key means each of them needs the new value before it can make another call.
One detail we will not guess at is the base address of the API. Our help pages write endpoints as /api/v1/ followed by the resource, and the full host and request details are in the separate Que technical API documentation. Take the host from there. The paths in the rest of this guide are the ones our help documentation names.
The endpoints, in the order you meet them
Que’s API is organized around the same four objects you see in the Dash. Here they are in dependency order, with what each one needs and what usually creates it.
Satellites
A satellite is a machine running an instance of After Effects in your own environment. It asks Que for job data through Templater. You can point a campaign or an individual job at a specific satellite, which is how you decide where rendering happens. You must register at least one satellite before you can create a campaign.
There are two endpoints for this, and our documentation treats them as the exception rather than the rule. POST /api/v1/satellites/create registers a machine. It needs a name and a password that you choose. Satellite names must be unique across your organization, so a duplicate name returns an error. Creating a satellite does not give the machine access to your data. You then authorize it with /satellites/auth, using the same name and password. Finally a person still has to assign the Templater Bot to that satellite, by clicking Assign Bot in Templater’s QUE Configuration dialog, so the machine will actually process jobs. Our guide to what a Que satellite is and how to add one walks through the usual Templater route.
When a designer creates the satellite from Templater instead, Templater uses the machine’s name as the satellite name and generates a random password hash. It stores those, along with the machine’s hardware and software details, in a file called satellite.json in Dataclay’s application data folder. That is C:\ProgramData\Dataclay on Windows and /Library/Application Support/Dataclay on a Mac. Leave that file alone. Let Templater be the only thing that changes or removes it, and do not copy it to another machine or hand it to anyone.
Our documentation carries a warning here that is worth repeating plainly. Changing or deleting a satellite anywhere other than Templater or the Que Dash can cause trouble for jobs that already exist. If your integration has a reason to manage satellites through the API, test it on a campaign you do not care about first.
Templates
A template in the API is what the Dash and our marketing call an Autograf: an After Effects project whose layers have been rigged in Templater to take data. The endpoint is POST /api/v1/autografs (older help pages call it /api/v1/templates), and a successful request responds with the inserted autograf.
In practice, Templater makes this call for you. When a designer opens the Autograf Setup dialog and clicks Create Manifest, Templater writes a file named template-project.json into the same folder as the open project, then sends that file’s contents as the body of the request. Our documentation advises the designer to set a default target composition in the project before creating the manifest.
One behavior here catches people by surprise in a good way. Once a project is registered, its Que template ID is written into the project file’s XMP metadata. Copy the .aep to another machine, email it, put it on a shared drive, and the ID goes with it. It stays until a Templater user deletes the template from Que. Our longer walkthrough of how Autografs are built covers the designer’s side in more detail.
Campaigns
A campaign is a container for jobs, and it is the first object your code is likely to create on its own. The endpoint is POST /api/v1/campaigns. To create one you need the ID of an existing template and the ID of an existing satellite. Those become the campaign’s defaults, so any job you add later without naming a template or satellite inherits them.
Decide early how you will slice campaigns, because the slicing becomes your filing system and your access model. Our documentation gives the agency example: one campaign per client, with access to each campaign limited to the people who work on it. Campaigns also let you control how many renders a client gets and which rendering resources do the work. You can also create campaigns by hand on the Campaigns tab of the Dash, which is fine for a handful and tedious for many.
Jobs
A job is the data for one output. Each job is a JSON object of key and value pairs that Templater reads to change layers in the composition and to control After Effects itself. The endpoint is POST /api/v1/jobs, which creates a job in the campaign you specify. You need at least one campaign to exist first.
Three rules decide most of how a job behaves. First, you can use Templater’s reserved names as keys. Our documentation gives two examples: output sets the output name for that job, and target sets the job’s target composition. Second, a new job’s render-status is set to ready by default, and you can override that or any other default by including the key in your request body. Third, if you leave out aep or bot (older help pages call it _satelliteId), Que fills in the campaign’s default template and satellite.
That third rule is a design choice for you. If every job in a campaign uses one template on one machine, leave those keys out and let the campaign handle it. Your payloads stay small. If different jobs need different templates or different machines, send the keys explicitly, because a missed key will quietly fall back to the default rather than fail.
For more than one job at a time there is /jobs/batch, which creates multiple jobs in one request. Start with single jobs while you are learning the payload shape. Move to batch once a single job renders correctly, since a mistake in the payload is easier to read in one result than in a hundred.
Your first job, start to finish
Here is a realistic first integration, built from the documented steps. It is an illustration, not a customer story. A developer works at a company that wants a short welcome video for every new customer who signs up. A designer has already rigged a template with a text layer for the customer’s first name and registered it with Que. One office machine is set up as a satellite. The developer’s job is to make the signup flow create a Que job.
Step one is to confirm the groundwork in the Dash. The developer opens the Satellites view and sees the office machine listed. The template is there too. Neither of those came from code.
Step two is a campaign. The developer creates one called something like “Welcome videos” with a single POST /api/v1/campaigns, passing the template ID and the satellite ID as defaults. This happens once, not per signup. Many teams create it by hand in the Dash instead, and that is a reasonable call for a campaign that will exist for years.
Step three is the job itself. When a customer signs up, the app posts to /api/v1/jobs for that campaign. The data part of the body might look like this, using the property name the designer gave them:
{
"first_name": "Dana",
"output": "welcome-dana-1042"
}The first_name key is whatever the designer rigged, so yours will differ. The output key is a reserved name that controls the file name, which saves someone from opening anonymous files later. There is no render-status, because the default of ready is exactly what a new job should have. There is no aep or bot, because the campaign’s defaults cover both. How the request names the campaign is specified in the technical API documentation, so follow that for the exact field. Our article on custom output file names explains how the output value can also sort files into sub-folders.
Step four is the part developers skip, and it is the part that proves the integration works. On the satellite, the designer opens Templater, clicks the QUE logo button under Batch Assets and signs in. A browser window opens, they log in to their Dataclay account, click the check mark to grant Templater access to their campaign data, then switch back and click Authorize. After linking the campaign, they click the magnifying glass to open Job Selection Setup. There they can filter jobs by ID, by render status, by property values or by creation date. The render status filter has four values: Ready, Queued, Processing and Done. They pick Ready, open the QUE Inspector and look for Dana’s job in the list.
If the job is there, the designer uses the forward and back arrows in the Preview Data Merge section to step through the jobs inside After Effects. This is the moment of truth. If “Dana” appears in the right layer, the key names match and the integration is sound. If the layer is empty, the key name is wrong, and you have found that out with one job instead of a thousand. Only after this does it make sense to let the Bot loose on the campaign.
Step five is volume. Once single jobs look right, switch the signup flow to send jobs as they come, or collect them and use /jobs/batch. Templater’s Job Selection Setup pages through jobs in sets of 5 to 200, so a large campaign is processed page by page. Our post on running one Bot or many on one data source is useful when one machine stops keeping up.
Where first integrations go wrong
Most first-week problems come from a short list. The first is creating a campaign before a satellite or template exists, which the API will not allow. Check the Dash first. The second is mismatched property names, which produce valid jobs and wrong videos. Get the designer’s list of keys in writing. The third is forgetting that defaults fill in silently. A misspelled bot key is the same as a missing one to Que. The job simply goes to the campaign’s default machine. The fourth is a pasted token that breaks the day someone regenerates the key, which a variable prevents.
A last caution concerns satellites. Do not delete, rename or reconfigure satellites from code unless you have a real reason, and test it first. Our documentation warns that changes made outside Templater or the Dash can affect jobs already assigned.
When you do not need the API at all
Not every team should write code here. If your jobs come from a person rather than a system, the Dash is enough. Open the Campaigns tab, click the campaign table icon for the campaign you want, and click New Job above the table. You can add jobs from a file or by typing them in, and our guide to inserting a batch of jobs into Que covers the file route. That covers a producer who gets a list from a client every Monday. The API earns its keep when jobs are triggered by events in another system, such as a signup, an order or a form, and nobody should have to copy data across by hand.
There is also a timing question. If the template is still changing every day, wait. Every change to the rig can change the keys, and an integration written against a moving template gets rewritten. Let the designer lock the rig first.
The bottom line is simple. The Que API is small, and the job call is the easy part. Put your effort into the groundwork: a satellite that shows up in the Dash, a template that is locked, and a written list of the keys it expects. Then prove one job in Templater’s preview before you send a thousand. Do it in that order and your first job is also your last debugging session for a while.
That covers the path from an empty account to a first rendered job. Below are the questions developers ask us most when they start.
Frequently Asked Questions
Where do I find my Que API key?
Sign in to the Que Dash at que.dataclay.com, click your avatar and choose Account. On the Account page, click Generate next to the API Token field to create a new key, or click the copy icon to copy the existing one. The same page shows your Organization Key, which a designer needs when adding a satellite from Templater. Never share or post the key, and generate a new one if you think it has leaked.
How do I send the API key with a request?
Put it in an authorization header with the value Bearer, a space, then the token. We suggest storing the key in an environment variable in your API tool or app, for example access_token, and referencing it as Bearer . Pasting the raw token also works, but every saved request then has to be edited by hand when you generate a new key. A variable lets you change it in one place.
Why does my campaign request fail on a new account?
A campaign needs the IDs of an existing template and an existing satellite, which become its defaults. On a new account, neither may exist yet. Check the Que Dash for at least one satellite and one template before you call the campaigns endpoint. Both are normally created in Templater, by a person adding the machine through the QUE Configuration dialog and registering the project through the Autograf Setup dialog.
Can I create satellites through the API?
Yes. POST to satellites/create with a name and password, then authorize the machine with satellites/auth. Names must be unique in your organization. A person still clicks Assign Bot in Templater’s QUE Configuration dialog so the machine will process jobs. Our documentation says satellites are usually created in Templater instead, and warns that changing or removing satellites outside Templater or the Dash can affect existing jobs.
What happens if I leave the template or satellite out of a job?
Que fills in the campaign’s defaults. If a job request does not include aep or bot, the job uses the default template and satellite that were set when the campaign was created. That keeps payloads short when every job is the same. If different jobs need different templates or machines, send those keys explicitly, because a missing or misspelled key falls back to the default without an error.
What render status does a new job get?
A new job’s render-status is ready by default, which is what a job waiting to be processed should have. You can override it, or any other default, by including the key in the request body. In Templater’s Job Selection Setup, the render status filter offers four values: Ready, Queued, Processing and Done, so you can choose exactly which jobs a satellite picks up.
Can I create many jobs in one request?
Yes. The jobs/batch endpoint creates multiple jobs at once. We suggest starting with single jobs through the jobs endpoint until one renders correctly in Templater’s preview, then moving to batch. A wrong key name is much easier to spot in one job than in a hundred. For bulk loading from a file without code, the Que Dash can create jobs inside a campaign as well.
How do I check that my first API job worked before rendering?
On the satellite, sign in to Que from Templater with the QUE logo button under Batch Assets, link the campaign, then open Job Selection Setup with the magnifying glass. Filter by Ready, open the QUE Inspector and confirm your job is listed. Then use the arrows in the Preview Data Merge section to step through jobs in After Effects and check that your data lands in the right layers.
