An API (application programming interface) and an integration are sometimes confused. It can be challenging to see where one ends, and the other begins. Within this post, we'll look at API vs integration and provide API and integration definitions and functions.
APIs and integrations are both essential for data access. APIs often enable the transfer of data between systems.
Yet, systems also use APIs more broadly to enable one system to access another for non-data transfer reasons. As a result, some APIs do not enable integrations. Similarly, while integrations often rely on APIs, they do not do so exclusively.
Modern SaaS apps and web services use APIs and integrations extensively. Without them, apps turn into data silos. Since working in data silos is inefficient, APIs and integrations are essential for the modern software ecosystem.
What is an integration?
An integration is the code that allows one system (or app) to transfer data to or from another system. That is, the integration acts as a go-between for the two systems.
For example, an accounting system integrates with a CRM to ensure that customer name, address, payment status, and subscriptions sync between the two systems. Or a payroll system integrates with an email system to notify all employees of direct deposits for this period. In these examples, the CRM, accounting, payroll, and email systems each has an API that the integrations use.
Integrations improve efficiency by automating the processes by which related data aggregates within a single system. They allow users to spend more time working with data and less time collecting data.
What is an API?
An API is an interface that allows apps to communicate with each other. This code controls access to an underlying system or subsystem. Much like a UI (user interface) allows a human user to interact with an app via a screen, keyboard, or another input device, the API (application programming interface) allows other software to interact with an app programmatically.
For example, an API might connect a software system's front end (user interface and business logic) and the back end (database). Another API might connect various subsystems within a single application, such as connecting the contract subsystem to the organization subsystem. Both examples are internal APIs.
Yet another API (an external one this time) might enable data exchange with integration partners. In this example, the API is the connection point that an integration uses to access the underlying app and its data.
APIs today handle much of the work that allows systems to communicate both internally and externally. APIs often define the protocols which must be used, restrict the data which can be accessed or the queries that can be submitted, and use authentication to ensure that only valid users gain access.
What is an API integration?
An API integration is an integration that relies on an API for either input or output. While integrations can exist without APIs (sometimes called point-to-point integrations), this non-API pattern is increasingly less common due to scaling issues. As a result, most integrations work with an API on at least one end of the integration.
An API integration with Slack's REST API, for example, might allow your app to send a message to your #project-alerts Slack channel every time a user creates a new project in another app. Or you could use Shopify's GraphQL API to build an API integration that sends a purchase request to another app when someone makes a purchase.
What are the types of API integration?
API integrations can vary widely based on the type of API (Public, Private, Partner, and Composite) and the architectures commonly used for transferring data (SOAP, REST, and RPC). Also, whether the integration is query-based (pull) or event/webhook-driven (push). Finally, we might think of API integrations in terms of direction: one-way export, one-way import, or two-way.
You can combine these types, architectures, and directions to make different API integrations. For example, you might have a public API with the REST architecture supporting a one-way data export via webhooks. Another example might be a partner API with the SOAP architecture supporting a two-way data exchange. Also, organizations set up APIs in ways that can vary tremendously from one to the next, adding further complexity to API integrations.
What are examples of API and API integration?
We've touched on high-level use cases of APIs and API integration. In this section, we'll talk about a couple of APIs and some API integrations that could be built upon them.
GitHub offers two APIs for pulling data: a REST API and a GraphQL API. Both are used for pulling data from and modifying data in GitHub.
GitHub also offers pub/sub by way of webhooks. Using the REST API, you can create a webhook in GitHub to be notified when a record changes. Or, with custom API development your custom API integration might use the GraphQL API to push data into GitHub or to fetch data on a recurring schedule.
Your SaaS API integration might use the REST API to create a webhook in GitHub to alert your app when someone creates a pull request. GitHub then sends JSON data to your app at an endpoint you control. From there, you can email that data, send it to Slack, or whatever else you need to improve your business processes.
API and integration tools
As we've seen, APIs enable integrations, and integrations rely on APIs. But designing, building, and implementing API integrations is not as easy as grabbing an API and writing some code. For starters, you'll probably want to answer the following questions:
- Does the API offer access to the data which the integration needs?
- Will the data transfer be one-way or two-way?
- What type of data transfer does the API support?
- How frequently is the data transfer required?
And you'll want to dig deeper:
- What triggers the integration?
- How do you secure the integration payload in transit?
- If the integration fails due to network interruptions, can you automatically retry it?
Questions such as these are often addressed by tools that help developers create and deploy API integrations. Each of these tools abstracts some of the complexity of building API integrations and provides developers with pre-built functionality, which allows them to use APIs more easily for integrations.
A few of the most prominent integration tools are as follows:
iPaaS: The integration platform as a service is built for use within the enterprise. It enables a company to connect the apps it uses internally via integrations built on the platform. It includes connectors for many different APIs.
Unified API: This tool connects several APIs in a market horizontal (for example, ticketing systems) to a single API. This unified (or universal) API abstracts the complexity of connecting many APIs into one set of rules for connecting to a single API, thereby simplifying the process of building integrations with those underlying systems.
Embedded iPaaS: A platform that enables software companies to quickly build reusable, configurable integrations to the other apps their customers use and deliver them to their customers as a seamless part of their application. It has many of the features of an iPaaS (including connectors for APIs). It also includes an integration marketplace and customer-specific config and deployment functionality that a traditional iPaaS doesn't provide.
Conclusion
Perhaps the better way to frame API vs integration is as API plus integration. While an API is not an integration and an integration is not an API, each relies on the other to ensure that data transfers from one system to another.
SaaS companies have developed several tools and software solutions, including the embedded iPaaS, which can significantly streamline the build, deployment, and maintenance of integrations.
If you'd like to see how Prismatic's embedded iPaaS can help you enable SaaS API integrations for your app, we offer a free plan so you can jump right in and check it out.
You can also schedule a demo and we'll walk through your use case for API integrations and how Prismatic can help.
