What Is an API? Plain-English Guide + Integration Examples

What is an API, how does it work and when do you need one? Follow one sale from POS to accounting and compare three integration options on a labeled cost model.

By Aditya S November 1, 2026 Updated November 11, 2026 15 min read

An API is an agreed set of requests that lets one piece of software ask another to do something, without knowing how the other one works inside. If you are asking “what is an API?” because a vendor said “we integrate via API”, this guide turns that sentence into questions you can test and costs you can plan.

I’m Aditya S, Business Development Manager at Synetica, a tech-based business consultancy combining strategy and execution for Dreamers and Growing Businesses. Every example below is a fictional fixture you can replay with a developer or vendor. I am not citing Synetica client results, ranking products, or giving security or legal advice.

You’ll watch one sale travel from a POS app to an accounting app, learn how an API differs from the words people confuse it with, meet the parts of a request, and see the mistakes that cost founders money. Then we’ll compare three ways to connect two systems on one first-year scope.

TL;DR — the whole guide in five lines

  • An API is a contract, not a product: it states what you may ask, how to ask and what comes back.
  • Integration quality shows up when things fail: a retry that creates a second invoice is a defect, not bad luck.
  • One shared contract beats many private links: four apps wired pairwise need six connections; one shared layer needs four.
  • Read the documentation before you sign: limits, errors, versioning and keys decide whether the integration survives a year.
  • Plan for keys, limits and change on day one: an API you cannot secure, monitor or version is a liability.

A technician checks one glowing docking port joining two different mail sorting machines

What is an API? A short definition

An API, or Application Programming Interface, is a documented way for one program to request data or actions from another. Think of a restaurant. You do not walk into the kitchen. You tell the waiter what you want from a fixed menu, and the waiter brings back the dish or a clear “we’re out of that”.

Three parts do the work. The request is what the caller asks for. The response is what comes back, usually with a status that says whether it worked. The contract is the documentation that fixes the names, formats and rules, so both sides can change their insides without breaking each other.

On the web, most business APIs are called over HTTP and exchange data in JSON, a plain text format of labeled values. That is why a POS, an accounting tool and a website can talk even when different teams built them in different languages.

Map where these records sit in your business system.

Why does an API matter for your business?

An API matters because disconnected systems make people the integration layer. If a cashier closes a sale and a bookkeeper re-types it into accounting, the human is the API, and humans are slow and make typos.

Here is the fixture. A fictional café sells 3 items at an assumed IDR 45,000 and 2 items at IDR 30,000 on sale POS-118: 3 × 45,000 + 2 × 30,000 = IDR 195,000. Today the bookkeeper re-keys about 40 such sales a day. With an API, the POS sends each sale to the accounting app the moment it closes, and nobody re-types anything.

The catch is that the connection must behave when things go wrong. Networks drop. The fix is a contract that says what a repeated request means. Many APIs accept an idempotency key, a unique label such as POS-118, so that sending the same request twice produces one invoice, not two.

Fictional sale POS-118: POS posts an invoice with key POS-118, accounting replies 201; the reply is lost, the retry with the same key returns the same invoice

Open the request-flow diagram at full size.

How is an API different from similar terms?

Most confusion comes from five words that sound alike but do different jobs. Getting them straight stops you buying the wrong thing.

TermWhat it isWhat it doesExample
APIA documented contract for requestsLets one program ask another to actPOS asks accounting to create an invoice
IntegrationThe finished connection between systemsMoves data or actions across systemsSales flow from POS to ledger daily
WebhookA call the other system makes to youPushes an event when something happensPayment app tells you “paid”
SDKA code toolkit that wraps an APISaves developers time calling itA library for the accounting API
DatabaseStorage with rules for recordsKeeps records correct and queryableTables of invoices and customers

An API usually sits in front of a database. It lets other systems use the data and rules without touching the tables directly. Our database guide explains why that protection layer matters.

Webhooks and APIs work as a pair. You call an API to ask; a webhook is the other side calling you to tell. A good integration often uses both.

How does an API work, with an example?

An API works as a conversation of one request and one response, with the contract deciding what each may contain. Follow sale POS-118.

The POS app sends a request to the accounting API: create an invoice for POS-118 with the two lines above, total IDR 195,000, labeled with the key POS-118. The API checks the key, the data and the rules, saves the invoice and replies 201 Created with the new invoice number INV-9001.

Now the reply is lost on the network. The POS never hears back, so it retries with the same key. In this fictional contract, the server recognizes POS-118, does not create a second invoice, and replies 200 OK with the same INV-9001. Another contract may replay the original success status; check its documentation. A poorly built one creates INV-9002, and the café is billed twice for one sale.

I recommend one demo question for any vendor: what happens if the same request arrives twice? The answer tells you whether the integration was built for real conditions or for the happy path. Map your riskiest integration in Blueprint & Prototype before you commit to a build.

Validate it in 2 weeks. Blueprint & Prototype maps which systems must talk to each other and tests a working prototype of the riskiest connection with relevant users before you approve production scope. Bring the one integration that would hurt most if it failed.

What are the parts of an API request?

Every web API request is built from the same few parts, and each one has a business meaning. Knowing them lets you read documentation without a developer.

  • Endpoint: the address you call, such as an invoices address. It names the kind of thing.
  • Method: the verb. GET reads, POST creates, PUT or PATCH changes, DELETE removes.
  • Headers: metadata about the request, including your API key or token.
  • Body: the data you send, such as the invoice lines.
  • Status code: the result. 2xx means success, 4xx means your request was wrong, 5xx means their side failed. 401 means authentication is missing or invalid and 429 means you asked too often.
  • Rate limit: how many requests are allowed per period before the API says slow down.
  • Version: a label such as v1 that lets the provider change things without breaking you overnight.
CodeMeaningWhat your app should do
200 / 201Worked / createdStore the returned ID, such as INV-9001
400 / 422Your request was wrongFix the data; do not blindly retry
401 / 403Not signed in / not allowedCheck the key and its permissions
429Too many requestsWait, then retry slowly
500 / 503Their side failedFollow documented retry policy; retain the same operation key

These status examples are a starting checklist. Ask the supplier to document the exact retry rules for each endpoint.

Ask which of these protect the money: keys that can be revoked, limits that stop a runaway script, and versions that give you notice before a change. Verify that the implementation enforces the documented rule; documentation alone cannot prevent duplicates.

Write the required records and rules into the Blueprint.

What types of APIs are there?

Choose the style from what the two systems need, not from what is fashionable. The families differ in how you ask and what they make easy.

StyleHow you use itStrong atWatch out for
REST over HTTPAddresses and verbs, usually JSONMost business integrations, widely understoodMany calls to assemble one screen
WebhookThe other system calls you on an eventReal-time notices such as paymentsYou must expose a safe receiving address
GraphQLYou ask for exactly the fields you wantComplex apps and mobile screensHeavier to secure and monitor well
SOAPStrict XML contractOlder enterprise and banking systemsVerbose, slower to build against
File exchangeScheduled CSV or XML dropBatch jobs where real time is not neededSlow feedback and fragile naming

For a typical Indonesian business connecting a POS, accounting and stock, REST plus webhooks is a safe default because it is widely supported and easy to test. Choose another style when a counterpart system forces it, or when you can name the measured problem it solves.

“We might need to scale” is not a measured need. Revisit the style when you can name the call that is too slow and what it costs.

Compare these choices against your actual build scope.

What are real-world examples of API integration?

Real examples are easier to judge when you name the two systems, the data that moves and the failure that would hurt. These are generic patterns, not Synetica client case studies.

  • POS to accounting: each closed sale becomes an invoice or journal. The hurt: a duplicate or missing sale. Our POS guide covers the front end of this flow.
  • Inventory to POS and books: stock moves update sales availability and cost. The hurt: oversold stock or a cost that never posts. See inventory integration with POS and accounting.
  • Payment provider to your app: a webhook confirms a payment. The hurt: an order marked paid when it was not, or the reverse.

In each case the integration has the same shape: a trigger, a request, a response, a retry rule and an alert when it fails. If you cannot describe your own version on one page, you are not ready to choose a tool.

What common API mistakes cost money?

The expensive mistakes are about habits, not products. I recommend checking these before you pay for anything.

  1. No retry or duplicate protection. The double-invoice example above. Ask for idempotency on anything that creates money.
  2. Keys pasted into code or shared chats. A leaked key is a leaked door. Store keys in a secrets store and rotate them.
  3. No monitoring. An integration that fails silently is found at month-end. Alert on errors and on “nothing arrived today”.
  4. Ignoring rate limits. A script that floods the API gets blocked at your busiest hour. Queue and back off.
  5. Building on an undocumented or unversioned API. A silent change breaks you without warning. Prefer documented, versioned APIs.
  6. No exit plan. Ask how you would export your data and who owns the integration if the supplier changes terms.

Security and privacy duties depend on your data and sector. Confirm them with your own security and legal advisers against current official sources; I assert no specific regulation here.

Turn these failure cases into supplier acceptance tests.

How much does API integration cost in the first year?

Compare the same scope over twelve months, including the people time. The model below is fictional planning arithmetic, not vendor prices, a market survey or a Synetica offer. Scope: one business, POS to accounting, about 40 sales a day.

Assumed cost, IDR millionManual re-keyingReady connectorCustom integration
Setup and mapping0324
Twelve-month subscription or hosting0126
Monitoring and alerts033
Training01.50
Maintenance and changes0012
Re-keying time2.5200
Planned first-year spend2.5219.545
Separate 15% reserve0.3782.9256.75
Funding envelope2.89822.42551.75

The manual column counts only re-keying: an assumed 6 hours a month at an assumed IDR 35,000 per hour, so 6 × 35,000 × 12 = IDR 2,520,000. It excludes the cost of a wrong or missing entry, which is why the cheapest column is not automatically the cheapest decision. The connector subscription is an assumed IDR 1,000,000 a month, or IDR 12 million a year.

The reserve is held funding, not an invoice. The model excludes taxes, the price of the applications themselves, data migration and growth in volume.

First-year fictional planned spend of IDR 2.52 million for manual re-keying, 19.5 million for a ready connector and 45 million for a custom integration, with reserves separate

Open the cost diagram at full size.

Do not read this as “connectors always win”. A custom build can be the right call when no connector exists or your rules are unusual. Count maintenance honestly either way. Compare the wider application cost drivers before you set a budget.

Pairwise links multiply; a shared contract does not. Four apps wired to each other need six connections. A fifth app needs four more. With one documented layer in the middle, four apps need four links and a fifth needs one.

Four fictional apps: six custom point-to-point links versus four links to one shared documented API layer

Open the shared-layer diagram at full size.

This is the logic behind integration platforms and ERP systems. Our ERP integration guide shows when separate apps with APIs are enough and when one shared system is the better answer. If a unified system fits, read what ERP is first.

How do you choose an API integration?

Write down the data, the trigger and the failure rules, then test a prototype against them. The tool is the last choice, not the first.

Use four gates, and do not skip one because a supplier says it is handled.

GateWhat you produceEvidence that it passed
1. Data and rulesWhat moves, from where, to where, and what must never duplicateOne page the business owner has signed off
2. DocumentationEndpoints, limits, errors, versions and keys read in fullQuestions answered from the docs, not from sales
3. PrototypeThe riskiest flow, including a dropped reply and a retryReplay produces one invoice, not two
4. OperationsMonitoring, alerts, key rotation and exportAn alert fires on a deliberately broken call

For agreed custom scope, Synetica’s 2B2G path is Blueprint & Prototype in 2 weeks, then Production Grade Software in 8 weeks, then Launch & Grow on an ongoing monthly retainer. That is ten weeks through prototype validation and production build. Not every integration needs custom work; a ready connector is the right answer when it passes your tests. Plan the production work after the prototype fixes scope.

If you are weighing an off-the-shelf tool against a custom one, our build-versus-buy framework walks through the trade-offs.

What does safe retry mean in a real API contract?

Duplicate protection must be implemented and documented; the word API does not provide it automatically. Malcolm Featonby describes an idempotent retry as causing:

“no additional side effects” — Malcolm Featonby, Amazon Builders’ Library.

For a concrete documented example, Stripe’s idempotent-request reference explains how API v1 replays the stored status code and response body after execution starts. A successful retry may therefore repeat the original 201 rather than change to 200. Our fixture’s 200 is one hypothetical contract, not a universal requirement. Check key lifetime, parameter mismatches and concurrent requests with the supplier. Test the contract before signing.

What would I advise before you commission an integration?

Bring one integration that would hurt if it failed and ask what happens when the same request arrives twice. If a supplier cannot answer in plain words, the rest of the proposal is decoration.

  • For a first product: use a REST API with webhooks, keep the contract small and prove the riskiest flow with real users.
  • For two apps you already own: check for a ready connector first, and test its retry behavior before buying.
  • For an existing integration: audit keys, monitoring and limits before adding features.

My next step would be to book a scoping conversation with your riskiest flow and its failure rules written down.

FAQ — Understanding APIs

What is an API in simple words?

An API is a documented way for one program to ask another to do something, such as create an invoice. It fixes what you can ask, how, and what comes back, so each side can change inside without breaking the other.

What is an example of an API?

A POS app sending each closed sale to an accounting app is a typical example. Another is a website asking a payment provider to confirm a payment.

What is the function of an API?

An API lets systems share data and actions safely and repeatably. It replaces manual re-typing and gives each system a clear boundary.

What is the difference between an API and an information system?

An API is a contract for requests between programs. An information system combines people, process, software and data to support a business activity, and it may expose or use many APIs.

Why is an API important for business?

It removes people as the integration layer, so data moves faster with fewer typing errors. It also lets you swap or add apps without rebuilding every connection.

Aditya S

Aditya S

Business Development Manager, Synetica.

Put it into practice

Need help putting this into practice?

We turn the ideas in this article into a prototype tested with real users in 2 weeks (from Rp49jt)—or production-grade software in 8 weeks (from Rp100jt).

Tell us what you need
WhatsApp