Dante Certification Level 3 – Chapter 05: The Dante Managed API

Level 3 – Chapter 05 – The Dante Managed API

If you’ve made it to Dante level three, you’re probably working in environments where things get pretty advanced. Maybe you’re managing dozens or even hundreds of Dante devices across multiple buildings, or you’re designing integrated systems that tie AV into larger IT workflows. In those types of environments, automation becomes essential, and that’s where the Dante managed API comes in. Let’s start with what an API is in the first place, especially if this is your first time working with one API stands for Application Programming Interface.

It’s essentially a set of tools that allows one piece of software to talk to another instead of clicking through menus and buttons in a user interface. An API lets you perform actions and request information programmatically from another application. In the case of Dante domain manager and Dante director, the API gives you a way to automate tasks, pull data or control devices programmatically without needing to log into the web interface. This can be incredibly powerful for system integrators, developers, or IT administrators who want to build custom dashboards, integrate Dante control into larger systems or streamline workflows.

Think of the API as a digital doorway into Dante’s functionality with the right key, which we’ll talk about later. You can open that door and start interacting with your Dante environment in more flexible and automated ways. Before we dive deeper into the managed API, let’s quickly revisit the difference between an unmanaged and managed Dante network. In an unmanaged Dante network, devices communicate directly with one another.

It’s a peer-to-peer network with automatic device discovery and no centralized control. This works well for small, simple systems. In contrast, a managed Dante network uses Dante domain manager or Dante director to provide centralized control. It introduces user authentication, role-based access and domain segmentation.

This adds a layer of security and allows Dante to operate across complex multi subnet networks In a managed environment, the Dante managed API gives you a powerful way to interact with your devices through software. When those devices are enrolled in DDM or director, that means you can start integrating Dante functionality into your own custom applications, control systems or system workflows. Instead of Clicking through the UI to make changes, you can write scripts or build custom tools that do it for you automatically, instantly, and consistently. Right now, the API allows you to do things like check the status of a device or an entire domain, make audio and video subscriptions, and even enroll or unenroll devices from the system all programmatically without clicking through a user interface.

This is just the beginning. More features and expanded capabilities are in development, so you can expect the API to become even more powerful with future updates. Let’s take a look at how the API fits into a managed Dante ecosystem. What you see here is a visual representation of how all the pieces come together.

On the left side, we have two different sets of Dante enabled devices. These could be rooms, zones, or functional groups within an organization. One of the key advantages of using Dante domain manager or a Dante director is the ability to segment these systems into logical groupings. Each group can operate independently without unwanted cross communication.

That kind of control simply isn’t possible in an unmanaged Dante network. In the middle, you’ll see DDM, but this could also be Dante director acting as the centralized management layer. This is where all the policy security and device management happen. It’s responsible for user authentication, routing control, device permissions, and overall network orchestration.

To the right of that, we introduced the graph QL API, which is part of the Dante managed API. This is what enables communication between DDM or director and external control systems or software platforms. The API acts as a bridge allowing developers and integrators to tap into the power of the Dante network programmatically, what can you do with it? Well, a lot.

You can build custom dashboards that show live device status, routing configurations, and health metrics. You can use the API to extract data such as which devices are online, how they’re connected, or whether any errors are occurring. You can feed that data into analytics and visualization tools, making it easy to monitor complex systems. At a glance and perhaps the most common use case is building simplified control interfaces.

These allow non-technical users to operate the system with a touchscreen or tablet pressing a single button to trigger complex routing or switching actions behind the scenes with the API. All of that is possible without ever needing to open Dante controller. As you saw, the managed API is built using GraphQL, but what is GraphQL in the first place? Well, GraphQL is a modern way for software applications to ask for and send data.

It’s a query language for APIs, but more than that, it’s a smarter, more flexible alternative to traditional REST APIs. Let’s take a step back and talk about what a rest API is. REST stands for representational State Transfer. It’s been the standard way for systems to talk to each other over the web for years.

In a REST API, you usually access different pieces of information through specific endpoints. For example, you might go to one endpoint to get a list of devices, another to get their settings and another one to get their status. Each of these endpoints gives you a fixed set of data whether you need all of it or not. That brings us to one of the biggest limitations of rest, something called over fetching.

That’s when you ask for one piece of information, but the system responds with far more than you actually need. Imagine ordering a cup of coffee and getting the entire menu delivered to your table plus a bunch of desserts you didn’t ask for. It’s wasteful. It slows things down and it creates extra work on your end to sort through it.

GraphQL solves this problem with GraphQL. You don’t have to pick from a fixed menu of endpoints. Instead, you describe exactly what you want, nothing more, nothing less. You might say, I want the name of each device.

Its IP address and whether it’s online and that’s all. The server gives you clean, simple, and efficient. When we say GraphQL is more flexible than rest, that’s what we mean. It puts you in control of the data.

In complex systems like Dante domain manager or Dante director where there’s a lot of information moving around, GraphQL helps you stay focused, stay efficient, and build exactly the workflows you need with GraphQL. Not only are you avoiding over fetching, but you’re also cutting down on the number of API calls you need to make. That means less network traffic, faster performance, and a more efficient way to get the exact data your system needs. Okay, now let’s talk about control.

Control is at the heart of every AV system, whether you’re managing audio routes, switching sources, or triggering presets, the ability to control your environment quickly and reliably is essential. With Dante, we’ve always understood that the great news is that this level of control doesn’t always require complex programming or custom development. In fact, we’ve already built control interfaces that are ready to go and they’re available for download directly from our website. If you’re using platforms like a MX or Crestron, we’ve developed modules that make integration fast and easy.

These let you connect your Dante enabled systems directly to your existing control infrastructure. No need to start from scratch. We’ve also integrated with Bit Focus companion, which works beautifully with inexpensive stream deck devices. That means you can build highly functional customizable control surfaces with labeled buttons and visual feedback using affordable off-the-shelf hardware.

Here’s the best part. You don’t need to be a programmer to make this work. Even if you’ve never written a line of code, you can still build a system where a single button press can switch audio and video routes, trigger presets, or monitor device status. If you want to explore this further or see what third party tools and integrations are currently supported, we’ve put together a dedicated webpage that includes downloadable modules, sample projects, and the latest updates for platforms like Crestron, A MX and Bit Focus companion, the other primary application for the Dante managed API is the ability to integrate real-time monitoring of your Dante devices directly into your own centralized systems.

This can be a game changer, especially if you’re a system integrator who also acts as a managed service provider. Imagine having multiple client sites each with its own Dante deployment. With the Dante managed API, you can set up automated queries that report back to your central monitoring platform, giving you a live view of device status, routing changes and system help all in one place. This level of visibility is incredibly valuable for remote management, proactive troubleshooting, and delivering a high level service to your clients.

We’re already seeing our partners take full advantage of this. For example, Domos and A-V-I-S-P-L have built this type of integration directly into their managed service platforms. A VI P’S Symphony Enterprise Monitoring tool is a perfect example. They’ve incorporated the Dante managed API into their software to give it service managers a single pane of glass, not just for AV but for the broader IT ecosystem as well.

If you are looking to build something like this for your own organization, whether you’re an OEMA service provider or a software developer, you absolutely can. At the end of the day, this isn’t just about getting more data. It’s about turning that data into actionable insights that keep your systems running smoothly and your users happy. At the core of GraphQL is something called a schema.

This schema describes all the data that’s available and it defines the operations you can perform. One of the great things about GraphQL is that it works for both reading and writing data. Whether you’re pulling information like checking the status of a device or a list of domains, that’s called a query, or if you’re making changes like updating a subscription or sending a command that’s known as a mutation, that schema acts like a map for the client, so there’s no guesswork in involved, but what about the syntax? Well, even if you’re not a full-time developer, it’s approachable.

Plus tools like Altair or Graphical can even auto complete your queries, which makes building and testing your API calls a lot easier. When we talk about how this fits into the Dante ecosystem, both Dante domain manager and Dante director act as the GraphQL server. That means they handle the logic. They aggregate data from all your managed Dante devices and they serve up that information securely to any authorized client.

GraphQL runs over standard HTTP or H-T-T-P-S, which makes it extremely flexible. Any client that can speak HTTP, whether it’s a dashboard, a tablet, a custom software tool, or even a browser can communicate with the API assuming proper authentication is in place, and because H-T-T-P-S is supported, that connection is encrypted and protected using trusted certificates. It’s also worth noting that when you’re working with GraphQL in this ecosystem, network architecture and access control matter far more than physical server location. Whether you’re DDM or director instance is running locally or remotely, the key is ensuring that your API client can reach it securely over the network and has the right permissions in place.

Okay, let’s see. A real world example. Imagine you manage AV in a stadium on game day. You want the system to automatically verify all audio and video devices are online, and then route flows to predefined zones with the Dante managed API that can be triggered with a script.

No more manual clicks, no more scrambling to find which switch a device is connected to just automation. Fast and reliable. Of course, with great power comes great responsibility. The API uses token based authentication and it respects the role based permissions you set in Dante domain manager or Dante director, so if a user doesn’t have permission to make a subscription to a device in the ui, they also can’t do it through the API that keeps your system secure.

Who’s actually using this today? Quite a few people. System integrators are using it to streamline deployment processes and ensure devices are configured properly every time Enterprise IT teams are integrating Dante status into their NOC dashboards and developers are building custom front ends that give end users a simplified interface for controlling Dante routes without ever logging into DDM or director. If you are interested in working with API yourself, the best place to start is the official documentation.

This guide is free and available to everyone and you can download it directly from the link shown on screen. It includes a full schema example, queries and mutations and tips for setting up authentication. You can use Graphical Postman, Altair, or your favorite API tool to experiment. Let’s take a look at how to access the API using Dante Domain manager.

These keys can be generated directly from the Dante Domain manager web interface. The keys don’t expire on their own, but they can be revoked at any time using the same interface before any keys can be created. Someone with the site control role must first enable API key management. To do that, you’ll need to navigate to the settings section, then choose network and security under the API heading, make sure the option to allow users to create and manage API keys is selected.

Keep in mind That this setting is turned off by default, especially if you’re upgrading from DDM version 1.4 or earlier or installing DDM Fresh for the first time. Once key management is enabled, any user can create an API key. The key inherits the permissions of the user who creates it. So if you’re an administrator and want to create a key with limited access, the best approach is to first create a new user account with the appropriate permissions.

Then log in with that account to generate the key to create an API key. You’ll go to settings and then personalization and API keys in the web UI at the API access key section, click the option to add a new key. You’ll be asked to give it a descriptive name, which in our case will be third edition and then click okay. This is helpful for identifying the key later in logs.

After that, a dialogue box will appear showing the newly created key. You need to copy and store this key right away because it won’t be shown again. If you lose it, you’ll have to revoke it and generate a new one and remember, don’t share your key with anyone else. Doing so would give them full access to your Dante Domain manager account.

Once created, the new key will appear in your list of API access keys. On the same page, you’ll see the name you gave the key a partially hidden version of the key itself to help identify it and its associated permissions. There’s also a button you can use to remove the key if needed. There are a few limitations to be aware of when using the managed API devices that are running in what’s called legacy mode.

Typically, Dante devices with firmware older than version 4.0 are not supported. These devices will still function as usual legacy devices within Dante Domain manager, but they won’t appear in API queries and can’t be controlled using the API. Also, virtual devices used for shared audio groups are not currently recognized by the managed API. Just like with legacy devices, these will still work within the system but won’t be visible or controllable through the API.

And finally, the managed API only supports native Dante audio flows AES67 and ST2110. Channel subscriptions aren’t supported at this time. Alright, now that we’ve got our API key ready, we’re going to start using a GraphQL client. In this case I’ll be using Alt alter, but you could also use something like Postman or really any tool that supports GraphQL.

Just to be clear, what we’re demonstrating here is the potential of the API itself. We’re not tying this to any specific control platform like Stream Deck A MX or Crestron. The goal here is to understand what the API can do so you can use it wherever it makes sense in your environment. To begin will create a new environment inside Altair and give it a name.

I’ll call it DDM. Once that’s set up, we need to select the environment and configure it with the API key we generated earlier along with the URL for the API endpoint. While in the environment settings, we go to the header section. In the key field we type authorization and in the value field we paste the API key.

Once that’s done, we click save or done depending on your tool, and then we paste the API endpoint URL into the main request area. You can find this URL in the same spot where you created the API key under settings, then personalization and API keys. Now we’re ready to start writing our first query, but before jumping in, let me show you something important. The docs section, this is where the API documentation lives.

When you are connected to the endpoint, the schema shows up here automatically and it lets you explore the structure of the API, what data is available, how it’s organized, and what fields you can include in your requests. If I look for a query called Domains, I can see exactly what it does and what information I can pull from it. It’s all about the structure. You don’t need to be a developer, but you do need to be precise.

GraphQL is strict about syntax, but at the same time it’s self-explanatory. What you see is what you get. Let’s walk through our first query together and for the next ones we will just copy and paste our script so that the chapter can go faster. Okay, we type the word query, then an open curly brace.

On the next line, we type domains, open another curly brace, press enter again, and then we start listing the fields we want. If you’re not sure what fields are available, just go back to the docs and check for this basic demo, I’ll just ask for the ID and the name of the domains. That’s it. Then we click send request, and over on the right side of the screen we should see the results come back a list of all current domains each with its ID and name.

For instance, if I now wanted to know all the devices I’ve gotten in the unmanaged domain, I can open a new tab, paste in a query I’ve prepared earlier and hit send. If everything works, we’ll get a list of devices in the unmanaged domain along with all the information we asked for, like name, address, product model, and id. We can verify directly in DDM if the devices I see in Alt alter are the same in DDM, and yes they are. So far everything we’ve done is retrieving data, asking the system questions and reading the responses.

But what if we wanted to make changes? What if we wanted to actually do something like enroll a device or create a subscription between two devices? Well, for example, if I wanted to enroll the speaker into the corporate domain, we can use this other script. We paste it on a new page and we can see that we just need the device IDs and domain ID information, which we already have.

When we press send request, we can see that the device immediately disappears from the unmanaged domain and moves into the corporate domain. The same is true if I want to unenroll the device from this domain, we will have to change the mutation to devices unenroll and leave only the device IDs. Okay, now it’s time to make a subscription using the API. To do that, we’ll have to use a mutation.

Again, if you’re curious about what kinds of mutations are available, just go back to the docs. You’ll find options to enroll devices, unenroll them, create subscriptions, remove subscriptions and more. In this case, let’s make a subscription in the corporate domain. I wanna connect a Bluetooth AVIO device to a mixer.

The mutation is already written out and all I need to do is customize it. I take the device ID for the receiver, the one we want to subscribe and paste it into the input field. Then I specify the channel index on that device. Next, I enter the name of the transmitting device and finally the name of the channel I want to subscribe to.

Then I click send request, and just like that the subscription is made. You can see it appear immediately in Dante controller, and if I want to unsubscribe the channel, I just send another mutation, but this time I leave the channel names blank. I hit send again and the subscription disappears from Dante controller. That’s it.

So what we’ve seen here is just the beginning of what’s possible with the Dante managed API using Dante domain manager. Once you understand the structure of the queries and mutations, you can build powerful workflows to monitor, configure, and control your entire Dante environment, all without touching the user interface. Now, let’s do the same, but with Dante Director. Dante director offers early access to some features of the Dante managed API.

Just like with DDM authentication is handled through API Keys. These can also be created directly within the Dante Director web interface. When you generate a key, you’ll have the option to apply access restrictions. For example, you can choose whether the key provides full access across all sites, or you can restrict it to only certain sites.

API, keys and Dante Director don’t expire automatically, but their permissions can be edited and they can be revoked whenever needed through the interface. To generate a new API Key and Dante director, you’ll need administrator privileges from the web ui. Head to settings, then open the API keys section, click on add account key and enter a descriptive name to help you track its usage in event logs for us. The name will be third edition.

Then choose the level of access, whether you want it to have full access to all sites or restrict it to selected sites. Once that’s done, click add key. A dialogue box will appear with your new key. Just like with DDM, make sure to copy and save the key right away.

It won’t be displayed again and if it’s lost, you’ll need to delete it and generate a new one. Again, never share your key. Doing so would give others access to your Dante director environment. After creation, the key will appear in your list of service API Keys.

You’ll see its name, a partially hidden version of the key and its associated permissions. You’ll also find buttons that allow you to edit those permissions or delete the key entirely. Okay, let’s move on to Altair again to see how it works. Once we have already created another environment called director, remember we have to add the API key we generated earlier along with the URL for the API endpoint.

We’ll go to the header section type authorization, then paste the API key and click save. Then we paste the API endpoint URL into the main request area. You can find this URL in the same spot where you created the API key under Settings API Keys. First, I’d like to know all the sites that I manage in my director account to request that information.

We use the same script as before and we see four sites appear. The one we’ll use will be the Cambridge office Dash training. Of course, I would like to know if all my devices inside that site are healthy, all add a new tab for a new query and paste the script from before. Then we send the request and if everything is okay, it will tell us.

Okay, but if you have an issue in the domain, it may show an error. We can do the same if we add a variable. The variables section in Alt Alter is essential for flexible and secure interaction with GraphQL APIs. It allows you to test queries more efficiently and follow best practices for real world development.

Now, all query devices inside the site, but to do that, I need the site id. Where do I get this value? Well, if we go back to our first query, we’ll be able to see the site ID for every site. In this case, we’ll only use the Cambridge office dash training value.

Then we open the variables section at the bottom, press enter between the curly brace and type domain id and here we open quotes, paste the domain ID and then close the quotes. Once we send the request, we see all the information and status from every channel and device in this domain. Okay, let’s do the same thing we did with DDM. Let’s subscribe and unsubscribe some channels from devices that are enrolled in the director site.

Our plan is to subscribe to channels from the Bluetooth AVIO to the mixer in the Cambridge office training site. So to do that, we just copy and paste the following script with the mutation and we’ll see how the AV O subscribes to the mixer in real time. If I want to undo it, we paste this other script that we previously used and voila, just to be clear, everything we’ve done here in Altair was meant to show you what’s possible with the API. That doesn’t Mean you need to go through this process every time you set up a system.

If you are using platforms like Crestron, A MX, or Bit Focus Companion, the hard work has already been done. Those systems have integrated the API for you, so all you need to do is configure it to fit your environment. The point here was to help you understand how it works under the hood and to show you the kind of control that’s possible when you need it. Now that we’ve explored the Dante managed API, you’ve seen what makes this tool so powerful.

At its core, it’s built on GraphQL a modern, flexible way to interact with data. When a GraphQL service is up and running, it validates and executes queries in real time, giving you exactly the data you ask for in the form you need with just a single request. What makes this approach so valuable is how well it adapts. As your needs change, your API can evolve with them without the complexity of managing different versions, and because your queries mirror the structure of your data, it’s intuitive and efficient, whether you’re retrieving device status, automating control, or monitoring a large scale Dante deployment, this is what powers the Dante managed API.

It transforms Dante domain manager and Dante director from a manual management tool into a programmable platform that opens up all kinds of new possibilities, automated workflows, custom dashboards, remote monitoring, and seamless integration with control systems you already use. When we talk about extending control, we’re really talking about giving you the freedom to design workflows that match how your team works, whether that’s for a broadcast environment, a university campus, a corporate network, or a full scale live production. And if you’re ready to start building, the best place to begin is with the Dante managed API User Guide. It’s free, it’s available to everyone, and it gives you everything you need to get started.

Whether you’re new to GraphQL or already comfortable writing queries, you’ll find clear examples, descriptions of available operations and guidance on how to discover what’s possible through the schema itself. So if you’re wondering, can I automate that or can I control that remotely, the answer is likely yes. Almost everything you see in the Dante UI is available in the API and we’re continuing to expand its capabilities as new features are added. Download the guide, experiment with your first queries and start building the Dante managed API gives you the tools.

Now it’s up to you to create the solution that fits your needs. Thanks, and see you in the next chapter. Okay.