What is API integration?

While some businesses may dream of running a single piece of software, for many, the reality is more like a nightmare of disconnected apps and siloed data.

For instance, to actually contact people who completed your online survey, you need to get their email addresses out of your form-handling app and into a mailing system. 

Manual transfer is possible - after all, .csv exports and good 'ol copy-and-paste still exist. But this is tedious, time-consuming, and prone to human error.

Fortunately, programmers have developed something called Application Programming Interfaces (APIs), protocols that help apps "talk" to each other with little to no human involvement.

When we connect, or integrate, software using APIs, we can transform our app stack from a series of disjointed programs to a connected network.

So, what are API integrations, and how can you use them?

What is an API?

An API is a set of rules and protocols apps use to communicate with each other.

It defines the methods and data structures that developers can use to interact with an external software component, operating system, library or service.

This enables seamless integration and functionality sharing between different software systems.

API endpoints

Under the hood, many apps use certain standardized methods of retrieving data or performing actions within the runtime environment.

APIs expose these methods externally, allowing other apps to access each other’s resources remotely and programmatically. This connectivity is the principle behind the promise of integrating apps and streamlining workflows.

An app's underlying methods are accessed remotely via API endpoints - URLs corresponding to those key functions.

For example, this is the API endpoint for sending an email in Gmail:

POST https://gmail.googleapis.com/upload/gmail/v1/users/{userId}/messages/send

And here’s the API endpoint for creating an invoice in QuickBooks.

POST https://quickbooks.api.intuit.com/v3/company/<realmID>/invoice

So far, so technical. But endpoints are just the start.

Calling an API

APIs come in a variety of flavors, or protocols. REST (Representational State Transfer) is the most popular, though some systems use SOAP (Simple Object Access Protocol) or RPC (Remote Procedure Call).

You access another app's resource by instructing your software to make a request, or a "call", to an API endpoint. The server then executes certain functions and sends back a response.

This request/response pairing, inherent to a RESTful API interaction, is the basis of app integration, through input and output.

The request - input

• Endpoint URL: The URL to the server resource the client wants to access.

• HTTP (Hypertext Transfer Protocol) method: The type of action the client wants to perform on the endpoint. They include GET (retrieving a resource on the server), POST (creating a new resource), and DELETE (deleting a resource).

• Headers: High-level information including security credentials and the format of the request’s body.

• Body: Any data you’re sending to the server to help it execute the request. The body is also known as the "payload", typically structured as a JSON object.

The response - output

• HTTP status code: A three-digit number indicating the request’s outcome - for example, 200 (success) or 404 (not found).

• Headers: More information about the server’s response.

• Body: The data the server sends to the client in response to its request. For example, this could be certain data the client requested from the server, often formatted as JSON just like the request body.

The essence of this request/response pairing is in the exchange of the two bodies. For instance, if you wanted to search Google for "cool hats" via API, this search string would be passed in the request body, while search results would be returned in the response body, as structured data.

What is an API integration?

If APIs are like ports for accessing app functions, integrations are the bridges that connect software functions together.

Integrating apps helps them work together as if they’re part of a single cohesive system. In this way, we can:

• Enhance apps with third-party features: API integrations let apps tap into features and data from other apps to improve the user experience. For example, Spotify’s API integration with Instagram lets us directly share the Spotify tracks we’re listening to on our Instagram Stories.

• Consolidate data from multiple apps: Using API integrations, we can consolidate performance data from multiple apps into a single reporting app. We then get a centralized, holistic view of our business’s performance across different sources and channels.

• Automate our workflows: Instead of manually moving data between apps for further manual processing, we can set up API integrations to automatically trigger our apps to execute actions when certain events happen in another app.

Benefits of API integration

Sure, we could manually do some of these tasks ourselves. But delegating them to automated API integrations has its advantages:

• High performance: API integrations can execute tasks much quicker than humans, improving our operational efficiency.

• Time savings: With our API integrations taking care of certain tasks for us, we free up our time for other impactful activities.

• Cost savings: We can build API integrations to carry out our workflows relatively inexpensively. This can free staff to perform alternative or higher-level tasks.

• Fewer operational errors: API integrations can operate independently without our intervention, lowering the risk of human error.

• Scalability: API integrations can effortlessly handle the growing volumes of requests you may experience as your business expands.

So, how can we create API integrations and reap these benefits for our business?

How to create an API integration

1. Code

API integrations are traditionally created using code. In other words, you would write your own, intermediary program that makes multiple API calls in sequence.

More often than not, these connections are just one part of a wider process or chain that involves sending, receiving and processing data, in and out of those apps, in your overall workflow.

Needless to say, coding an API integration requires developer skills. You’ll need a development environment for running your API integration and your chosen language. Whether it is Python, JavaScript or PHP, pretty much all languages have pre-built functions for calling remote resources like APIs.

A programmer builds a program that:

• Proves its security credentials with the remote APIs by passing authentication or authorization data. API keys or tokens are straightforward authentication methods, but methods like oAuth 2.0 become still more complicated.

• Sends their starting data to the first app - this acts as an input step.

• Parses the data received in the response. You may need to write code to transform the data’s structures into what’s required by the subsequent apps’ APIs.

• Write and send further API requests containing the parsed data. This is how data from one app can be acted upon in another.

• Add further code to receive and present the secondary data. That new data may be exported to a .csv file or shown in a web dashboard, depending on whether the developer is producing an interface or not.

As you can see, it is not exactly plug-and-play. And other issues to consider include:

• Automating your integration so you don’t have to send API calls yourself. One way of doing so is to set up a cron job, which is a type of task scheduler that can automatically execute functions according to specified time intervals.

• Programming your integration to handle errors that could crop up, like server errors.

• Navigating rate limits, which are API usage caps. Apps may impose these to protect their infrastructure from being overwhelmed by requests, or to charge for usage if you exceed their limit on free API calls.

Unless you’re a trained developer, doing all this can get quite tricky. Many software vendors produce API libraries that can turn the call/response process into much simpler language for making the coding process easier, but even these libraries are intended for use by developers.

Coding API integrations is like connecting software on hard mode. Luckily, there are alternatives to coding API integrations from scratch.

2. Connectors

Often developed by third parties, connectors are add-on tools designed to integrate specific apps for a limited - or even single - purpose.

For example, the Amazon Connector app exists to sync a retailer's Amazon product listings to their Shopify store.

Though a user would not know it, behind the scenes, connectors use API calls to instruct apps to execute particular actions. The connector’s developer has already written the necessary code to facilitate the process, but this code remains hidden behind a simple interface.

Setting up an API integration in this way is straightforward. We just need to install the connector using the graphical interface of one of the apps it integrates with - for example, the Shopify dashboard in Amazon Connector’s case. The connector provides its own guidance and walks the user through each step.

But connectors are compatible with only the apps they’re designed to work with. In addition, their capabilities tend to be limited to only one use case.

For example, being a Shopify app, Amazon Connector connects Amazon only with Shopify. Also, while the app helps import a user's Amazon inventory to their Shopify store, it can’t do the reverse.

3. Native integration

While connectors are add-ons to apps, a native integration is an official integration built directly into an app. It’s designed to connect the app with another specific app to carry out a limited range of actions.

For example, the Todoist app offers a native integration with Google Calendar for synchronizing tasks as calendar events. A user can set it up by using Todoist’s built-in settings to connect their Google Calendar to their Todoist account.

Native integrations, too, are facilitated via API calls the app’s developer has already coded into the app. As a result, native integrations are highly convenient - we don’t need to write any code or install add-ons to access the desired functionality.

If an app has a native integration with another app we want to integrate, we could rely on that, if it meets our needs perfectly. A problem arises, however, because app makers often pick a small list of partners with which to integrate.

If your preferred apps have not decided to partner, then it may be time to integrate them for yourself - and that’s where an integration platform comes into play.

4. Integration platform

Integration platforms are platforms designed to help connect a huge number of apps, without code and at your behest. They offer app modules that have already been configured with the code needed to connect to API endpoints, removing the complexity of code and offering more choice than both connectors and native integrations.

Take the Make integration platform, for example. It supports over 1,800 apps - from popular tools like Google’s suite of apps to more niche apps like Katana Cloud Inventory and Bolt IoT.

Using Make’s unique visual editor, building practically any integration you can imagine is possible. The process is simple: just drag and drop the relevant app modules into the editor and feed your data through them.

For example, this Make scenario adds Zoom meeting registrant details to a Google Sheet:

Need more complexity? This scenario syncs Google Calendar events to an Outlook Calendar, with three paths to support event creation, updating, and deletion:

Each case depicts an integration with the same full functionality a developer might write - but with no code in sight.

Make’s colorful visual editor makes it clear which apps have been connected and the actions they’ll take. Far from being a tedious coding exercise, the process of building an API integration can be surprisingly - dare we say it? - fun.

Creating API integrations with Make

Make gives you the same flexibility to create any API integration of your choice, just like with code, but with none of the technical difficulty.

• The integration is graphically laid out on a visual canvas. It doesn’t look like an intimidating wall of code.

• API endpoints are hidden behind user-friendly app modules. Although you’ll still be making API calls, these happen in the backend after you connect your modules and run your scenario.

• API authentication and authorization are taken care of. Just connect your apps to Make. Make’s app modules are configured to conform to each app’s unique authentication and authorization requirements, and will handle the rest.

• Create your integration to your exact specifications. Your workflows can be short and simple, or lengthy, branching and complex. Make provides the tools you’ll need to trigger apps to send and receive data, and execute actions when certain conditions are met.

• Automate your integration effortlessly. With Make’s scenario schedule settings, you can set up your integration to run automatically according to your preferred frequency. There’s no need to run your integration manually (although you can if you need to).

Full control using HTTP

Even though Make offers thousands of modules, sometimes you may want to call an API directly.

With Make’s HTTP module, you can create raw HTTP requests to any compatible API endpoint. You have access to all the key request fields we discussed earlier, but in a pleasing graphical format.

For example, we can use the HTTP module to automatically submit new URLs to Google Search Console.

Notice how the HTTP module in the screenshot above contains fields for an endpoint URL, HTTP method, headers, and a body - the key ingredients of an API call.

In this way, Make allows both novices and those with a little more programming know-how to build multi-step API integrations with all the power and familiarity of real, coded API calls - but in a straightforward visual interface.

How to design an API integration strategy

There are countless apps in the market, letting you build practically an infinite number of API integrations. Which ones should you prioritize?

Shape your API integration strategy using these pointers:

• Audit your workflows: List the workflows carried out by your staff in all departments - from sales to marketing, customer support, and more.

• Identify automation opportunity: Review your list of workflows to see which are particularly tedious for your team to do, but can easily be automated. Consider building API integrations to connect these workflows’ underlying apps and automate their activities.

• Estimate the impact: We’ve outlined some methods above, including using code, connectors, or an integration platform. Evaluate the extent of functionality your API integration needs, plus the estimated time, cost, and technical skill required to build it, when deciding on the appropriate method(s).

• Plan for the future:  As APIs may change over time, you’ll need to regularly maintain your API integrations so they continue to work as expected. Account for this maintenance cost when deciding which API integrations to build, and how.

The future of API integrations

Opportunities for harnessing applications via API calls are growing. Software developers are increasingly adopting an API-first approach to development, where making their product easy to integrate with other apps is a priority.

"API-first thinking means that your API is the first interface of your applications," shares Lars Trieloff, principal at computer software company Adobe.

"This means that the people developing against your API are your users, and your API needs to be designed with those users in mind."

This API-first approach is good news for businesses trying to do more with less. As software becomes more open, users will be able to connect more apps and automate more of their workflows, to streamline their processes even further.

Build your API integrations with Make

For anyone frustrated with their fragmented app stack, APIs are the answer - but they don't have to be in the foreground.

API integrations used to be the preserve of the developer, needing coding expertise to build. But not anymore.

With increasing API availability and new, visual tooling for forging those integrations, now anyone can turn their vision of seamless app workflows into reality.

Try Make for free by signing up for an account. Then, get ready to accelerate your productivity with API.