What Is an API Integration?
Picture a restaurant on a busy Friday. You sit at a table, you read the menu, and you tell the waiter what you want. You never walk into the kitchen. You do not need to know how the stove works or who chops the onions. The waiter carries your request to the kitchen, brings back the plate, and if the kitchen is out of something, the waiter tells you so.
That waiter is an API. The letters stand for application programming interface, which is a fancy way of saying "the agreed way one program asks another program for something." An API integration is a working arrangement where one of your business tools uses that waiter to talk to another tool, so that a person does not have to carry information between them by hand.
If you have ever copied an order from an email into QuickBooks, or exported a spreadsheet from your CRM so someone could upload it to your email tool, you have been the waiter yourself. An integration replaces you in that role. It is worth understanding how it works even if you never write a line of code, because the decisions that make an integration reliable are business decisions as much as technical ones.
The restaurant analogy, stretched a little further
The analogy is useful because it holds up under pressure. Let us push on it.
The menu is the API documentation. It lists what you are allowed to ask for. If the dish is not on the menu, the waiter cannot bring it, no matter how politely you ask. Some software simply does not expose the thing you want through its API, and no amount of cleverness fixes that.
The order ticket is the request. It has a specific format. A waiter who receives "something warm, maybe with chicken" will come back with questions, and a program does the same thing by returning an error. Programs are far less forgiving than waiters, so the ticket has to be exact.
The kitchen is the other system. It has its own rules, its own staff, and its own bad days. When the kitchen is slammed, your plate takes longer. When the kitchen changes its menu, your favorite dish may vanish.
The host stand is authentication. Not everyone gets a table. The restaurant checks your reservation before anyone takes your order.
The bell that rings when your food is ready is a webhook. Instead of you asking the waiter every two minutes whether your plate is done, the kitchen tells you when it is.
With that picture in mind, the rest of the topic becomes much less mysterious.
What actually travels between the two systems
When two programs talk through an API, they exchange small, structured messages over the internet. Most modern business tools use a style called REST, and the messages are usually written in a format called JSON, which is plain text arranged as labeled fields. A customer record might look like a short list of labels and values, such as a name, an email address, and a phone number.
Four kinds of requests cover most of what you will ever see. A program can read a record, create a new one, update an existing one, or delete one. If you remember those four verbs, you can read almost any integration proposal and understand what it is claiming to do.
Here is a plain example. Suppose your scheduling tool books an appointment. The integration reads the new appointment, checks whether the client already exists in your CRM, creates the client if not, and then creates a note on the client's record. That is three or four requests, each one a small question and answer, and the whole exchange takes a second or two.
Authentication, or how the other system knows it is you
Every serious API wants to know who is asking and what they are allowed to do. This is authentication, and it comes in a few common shapes.
API keys are the simplest. An API key is a long secret string, like a password for a program. Whoever holds it can act as you. That is convenient, and it is also the reason keys must never be pasted into a shared document, a chat message, or a public code repository.
OAuth is the arrangement you have seen when an app says "Sign in with Google" or asks "This app wants access to your calendar." Instead of handing over your password, you approve a specific app for a specific set of permissions, and the system issues that app a temporary token. The permissions are called scopes. A good integration asks for the narrowest scopes that do the job. If a tool that only needs to read your calendar asks for permission to delete your email, that is a sign to stop and ask why.
Tokens from OAuth expire, usually within an hour, and the integration is supposed to quietly renew them using a longer-lived refresh token. That renewal step is where many integrations die without anyone noticing, which we will come back to.
For you as a manager, the practical questions are simple. Who owns the account that the integration signs in as? What happens when that person leaves the company? Can access be limited to only what is needed? If the integration signs in as a former employee's login, it will stop working on the day that account is disabled, and it will probably be a Tuesday at the end of the month.
Rate limits, or why the kitchen will not take a thousand orders at once
Every API protects itself by limiting how many requests a single customer can make in a given period. These are rate limits. A tool might allow 100 requests per minute, or 10,000 per day. Go over, and the system answers with an error, commonly a status code called 429, which means "too many requests, slow down."
Rate limits matter most when something is being done in bulk. Importing 8,000 old customer records one request at a time can hit a limit within minutes. A well-built integration deals with this by pacing itself, by grouping records into batches where the API allows it, and by retrying politely after a pause. A poorly built one hammers the door until it is locked out.
Here is a hypothetical example, labeled as illustrative. Say your accounting tool allows 60 requests per minute and you want to sync 3,000 invoices. At full speed that would be 50 minutes of work if nothing else is running. If your daily sales sync also uses that quota, the two jobs can starve each other. The fix is usually scheduling, so that the heavy job runs at night, rather than buying a more expensive plan.
Webhooks and polling, two ways of finding out something changed
There are two ways one system can learn that something happened in another.
Polling means asking on a schedule. Every five minutes, the integration asks, "Any new orders?" It is simple and predictable, and it wastes effort most of the time because the answer is usually no. It also introduces a delay, since a change can wait up to five minutes before anyone notices.
Webhooks work the other way around. You give the first system a web address, and when something happens, it sends a small message to that address right away. It is the bell in the kitchen. Webhooks are fast and efficient, but they bring their own concerns.
First, you need to be sure the message really came from the system it claims to come from. Good vendors sign their webhooks with a secret, and the receiving side checks that signature before trusting the content. This is called a webhook signature, and an integration that skips it will accept a forged message from anyone who guesses the address.
Second, webhooks can arrive twice, or out of order, or not at all if your receiving side was down at that moment. A sturdy integration expects this. It records the ID of each event it has processed so that a duplicate does nothing, an idea called idempotency. The word is ugly and the idea is plain. Doing the same thing twice should leave the same result as doing it once. Without it, a repeated message creates two invoices, and your customer notices before you do.
Third, because delivery is not guaranteed, many teams combine the two methods. Webhooks provide speed, and a slower scheduled poll sweeps up anything that was missed.
Versions, or what happens when the kitchen redesigns the menu
APIs change. Vendors add fields, rename them, and eventually retire old behavior. To keep customers from being surprised, most vendors publish versions. Your integration is built against a specific one, such as version 2, and the vendor promises to keep it working for some period before ending it.
That promise has an end date. When a vendor announces that version 2 will be switched off in nine months, someone has to update every integration that depends on it. If nobody owns that task, the integration works until the day it does not.
This is why documentation of who owns each integration is as important as the integration itself.
What usually breaks
After years of watching small-business systems, the same handful of failures account for most of the pain. None of them are exotic.
| What breaks | What it looks like | Why it happens |
|---|---|---|
| Expired credentials | Data stops flowing and nobody is told | A token was not renewed, or the person who authorized it left |
| Changed fields | Records arrive with blanks in them | A vendor renamed a field or someone edited a custom field |
| Duplicate records | Two copies of the same client | A retry or repeated webhook with no idempotency protection |
| Silent failures | Everything looks normal, but the numbers drift | Errors were logged somewhere nobody reads |
| Rate limit lockouts | Sync fails during busy periods | A bulk job and a daily job compete for the same quota |
| Vendor outages | A burst of errors for an hour | The other system was down, and nothing queued the work for later |
Notice that the most damaging row is the silent one. A loud failure gets fixed that day. A quiet one corrupts your data for weeks. If you take one idea away from this article, take this one. Every integration needs somebody or something that tells a human when it stops working.
A worked example, with illustrative numbers
Imagine a small physical therapy clinic with two tools. One handles online booking. The other is the practice's billing system. Front desk staff currently copy each new patient from the booking tool into billing, which takes about four minutes per patient.
This is a hypothetical scenario, and the figures are made up for illustration. If the clinic sees 25 new patients a week, that is about 100 minutes of copying, plus the occasional typo in an insurance ID that causes a denied claim weeks later.
An integration could do the following when a booking arrives. It receives a webhook, verifies the signature, checks whether the patient already exists using email and date of birth as matching keys, creates the billing record if not, and writes the new record's ID back onto the booking so that a repeat message does nothing. If anything fails, it puts the booking in a review list and sends one email to the office manager.
Look at what the example contains. Authentication, a webhook, a signature check, idempotency, and a failure queue. That is the whole shape of a decent integration, in one small clinic. The code is secondary. The decisions about who gets the failure email, what counts as a match, and what happens when two patients share a name are the part that belongs to you.
Questions to ask before you buy or build one
You do not need to be technical to ask good questions. These are the ones that tend to separate careful vendors from hopeful ones.
- Which system is the source of truth for each piece of data, and which direction does it flow?
- What happens when the other system is down for an hour? Is the work queued, or lost?
- How will we find out if it stops working, and who gets the message?
- Whose account does it sign in as, and what permissions does it request?
- What are the rate limits on both sides, and does our volume come close?
- Does it verify webhook signatures and guard against duplicates?
- Which API version does it use, and who tracks the vendor's retirement notices?
- Who owns the code and the configuration if we part ways?
A vendor who answers these plainly is worth your time. A vendor who answers with reassurance and no specifics is telling you something too.
Build it, buy it, or connect it with a no-code tool
You have three broad routes. Many software products ship with ready-made connections to other popular tools, which is the cheapest and fastest path when the connection does what you need. No-code platforms let you assemble your own connections from building blocks, which suits simple flows and low volume. Custom code suits cases with unusual logic, high volume, or strict requirements about reliability and data handling.
The trade is cost against control. A ready-made connection is cheap until you need one behavior it does not offer. A no-code flow is easy to start and can become hard to maintain once it has forty steps and nobody remembers why. Custom work costs more at the start and gives you the most control. A sensible rule is to begin with the simplest option that is honest about its limits, and move up only when the limits start to cost you money.
A Puerto Rico note on resilience
Connectivity here is not an abstraction. A storm, a utility outage, or a neighbor's backhoe can interrupt service, and when it returns, a burst of delayed events can arrive all at once. This is a good test of an integration. Does it queue the work and process it in order when the connection comes back, or does it drop what it missed? Ask this before you rely on one. It is also worth confirming that your integration runs on infrastructure hosted outside the island, so that a local outage at your office does not stop your systems from talking to each other.
What you can do Monday morning
- Write down every place in your week where a person copies information from one tool to another.
- Next to each, note how often it happens and how long it takes.
- Mark the ones where a mistake is costly, such as billing, payroll, or patient records.
- For each tool involved, check whether its documentation mentions an API or a native connection to the other tool.
- Find out who currently owns the logins that any existing integration uses.
An invitation
Bring that list to your next vendor conversation. Ozcorp Scientific connects and operates business systems through InfraOps, which starts at $500 per month with vendor and license charges billed separately. Tell us which tools need to work together, and we will help you scope the next step.
Discuss your infrastructure requirements
Review the current service offer or schedule a conversation about the scope you need.
Stay in touch
Follow Ozcorp
Leave your details for occasional notes about new articles and Ozcorp updates.