Video Transcript

Hi. My name is James Davies. I’m going to talk a little bit about the Connecticut API’s.

And I love talking about this topic because it’s actually a question, I get the questions that are like, how do I move something from dev to production? Or how do I add a field to 100 Different forms at once without manually going into our form builder, and you use the kinetic API’s to do that.

So it’s fun for me to talk about this because it helps solve a pretty complex problem. And before I get into talking about what the kinetic API’s are, and what they do, I just want to talk just generically about what an API is.

So it’s an application programming interface. Wikipedia says it provides a specification for manipulating data structures, or initiating processes in a system. And I like to think of that in more simple terms. And that’s basically that it’s an API is a computer interacting with some other application in an automated fashion without someone actually having to kind of click around on the screen.

And so when Kinetic was building, our kid ops world, we needed to be able to automatically provision things and D provisioning things. So we kind of got into this practice of making sure we had really good API’s.

And over the course of the last couple of years, we just made them a whole lot better. And to do that, we had to kind of adopt a new methodology, we call that API first design. And that basically means that before we release some type of feature or new functionality, the development team sits down.

And with a pen and paper kind of sketch out what our API is going to look like, what parameters will be passed in, and what results will be returned to the whatever is calling that API. And that makes sure that we’re always completely extendable. And you can kind of automate every last thing that you do within the kinetic tools.

So really, everything that you can do within our application consoles, you know, creating a form adding a field to a form, you can completely automate that and do that VR API’s, not only in kinetic requests, but also in kinetic task for a job and filehub. So I like to think the proof is in the pudding.

So this is our kinetic request, CEE consoles, someone in here, clicked on the services cap, and then clicked on the forms. And you can see a list of form showed up here, behind the scenes, we’re actually doing an API call, you can kind of see that on the left hand side of the bottom of my screen, the lower left hand corner, and then the response that was that came back.

So we’re actually using our own API to build up our own consoles. And kind of in a similar fashion, this is an end user experience. This is a service portal, and they’re doing the exact same call. But we’re just drawing up the screen a little bit differently.

So we’re accessing the same data, and just drawing up things a little bit differently. So a couple of common API uses, I would say the most common is in our workflow. A lot of times we’re interacting back with kinetic requests, CEE.

So for instance, in an approval process, your workflow might actually create an approval, submission and kinetic requests to E. So we’re using those API’s all the time. But then also things like bulk bulk importing users or forms or submissions, you’ll use our API’s to do that, maybe backing up a space or moving something from dev to QA to production.

It’s common when you’re moving something from dev to QA to prod, or from one environment to another that you have some attributes that are specific to your environment. So attributes are like variables that we set in our spaces. And so you might want to make some type of migration script that actually keeps those things in sync as you move things forward.

So our API’s enable you to do that without having to manually go in and tweak things. So in order to make our API’s more accessible, we’ve concentrated on really trying to document our API well, right inside of all of our application consoles, you can help hit help in the upper right hand corner, and then choose reference docs. And in there, you can actually play around with our API, you can, you can do a specific call and see what the response is going to be. And then write your own script or your own program that’s going to interact with our applications.

So diving a little bit deeper, I won’t spend too much time. We are this is an example of a JavaScript call to our kinetic API. So API calls are made up of a couple of different parts, the URL, which is kind of like the address for how to get to the API, we’ve tried to make those very friendly.

So you can see in this example, we’re trying to get forms from the services cap. So that URL kind of describes exactly what we’re getting, then we tell it how we’re going to authenticate, in this case with a username and password. And then also, what are you going to do with the response?

So this is a kinetic API example. In JavaScript, you can do the same exact thing in any language, because we have a REST API. So Ruby hears the same exact example.

And so people are sometimes a little bit scared about working with API’s. So we came up with a Ruby SDK. And an SDK is a software development kit. And it’s kind of like a wrapper that makes interacting with our API a whole lot easier. So we’ve actually published this API.

It’s available for use in It’s very common for our customers to want to use this to script different parts, or different operations that will do for management of their application.

Again, moving things from one environment to another bulk importing or exporting. So our SDK works with kinetic request, kinetic task, file hub and bridge hub. We have a bunch of samples up there, and that library, this is the address on GitHub to it.

So you can check that out, I’m happy to talk with you or get you started if you have some type of process that you’d like to automate. And just a quick example of what it looks like. So the top example, here is without the SDK, that’s that same Ruby REST call that we were doing. And then the bottom is just that simplified using our SDK wrapper.

So in this case, you can just in one line, get a list of all your forms. And then finally, um, to interact with our API on the front end, we also have a wrapper, we call it react kinetic core.

And that’s so when you’re doing react front end development. We have this library that makes it just very easy to integrate, interact with our API to build up front end user experiences. And so you can check that out also on GitHub and use it within your React bundles and projects.

That’s a little bit about the kinetic API. Thanks.




Back to Videos

Try the Kinetic Platform Today.

When you're ready to learn how Kinetic Data can help you achieve better business outcomes, we're here to answer your questions.