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.
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.

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.
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.
| Term | What it is | What it does | Example |
|---|---|---|---|
| API | A documented contract for requests | Lets one program ask another to act | POS asks accounting to create an invoice |
| Integration | The finished connection between systems | Moves data or actions across systems | Sales flow from POS to ledger daily |
| Webhook | A call the other system makes to you | Pushes an event when something happens | Payment app tells you “paid” |
| SDK | A code toolkit that wraps an API | Saves developers time calling it | A library for the accounting API |
| Database | Storage with rules for records | Keeps records correct and queryable | Tables 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.
| Code | Meaning | What your app should do |
|---|---|---|
| 200 / 201 | Worked / created | Store the returned ID, such as INV-9001 |
| 400 / 422 | Your request was wrong | Fix the data; do not blindly retry |
| 401 / 403 | Not signed in / not allowed | Check the key and its permissions |
| 429 | Too many requests | Wait, then retry slowly |
| 500 / 503 | Their side failed | Follow 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.
| Style | How you use it | Strong at | Watch out for |
|---|---|---|---|
| REST over HTTP | Addresses and verbs, usually JSON | Most business integrations, widely understood | Many calls to assemble one screen |
| Webhook | The other system calls you on an event | Real-time notices such as payments | You must expose a safe receiving address |
| GraphQL | You ask for exactly the fields you want | Complex apps and mobile screens | Heavier to secure and monitor well |
| SOAP | Strict XML contract | Older enterprise and banking systems | Verbose, slower to build against |
| File exchange | Scheduled CSV or XML drop | Batch jobs where real time is not needed | Slow 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.
- No retry or duplicate protection. The double-invoice example above. Ask for idempotency on anything that creates money.
- Keys pasted into code or shared chats. A leaked key is a leaked door. Store keys in a secrets store and rotate them.
- No monitoring. An integration that fails silently is found at month-end. Alert on errors and on “nothing arrived today”.
- Ignoring rate limits. A script that floods the API gets blocked at your busiest hour. Queue and back off.
- Building on an undocumented or unversioned API. A silent change breaks you without warning. Prefer documented, versioned APIs.
- 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 million | Manual re-keying | Ready connector | Custom integration |
|---|---|---|---|
| Setup and mapping | 0 | 3 | 24 |
| Twelve-month subscription or hosting | 0 | 12 | 6 |
| Monitoring and alerts | 0 | 3 | 3 |
| Training | 0 | 1.5 | 0 |
| Maintenance and changes | 0 | 0 | 12 |
| Re-keying time | 2.52 | 0 | 0 |
| Planned first-year spend | 2.52 | 19.5 | 45 |
| Separate 15% reserve | 0.378 | 2.925 | 6.75 |
| Funding envelope | 2.898 | 22.425 | 51.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.
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.
Why does one shared API layer beat many private links?
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.
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.
| Gate | What you produce | Evidence that it passed |
|---|---|---|
| 1. Data and rules | What moves, from where, to where, and what must never duplicate | One page the business owner has signed off |
| 2. Documentation | Endpoints, limits, errors, versions and keys read in full | Questions answered from the docs, not from sales |
| 3. Prototype | The riskiest flow, including a dropped reply and a retry | Replay produces one invoice, not two |
| 4. Operations | Monitoring, alerts, key rotation and export | An 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.
Related Posts
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).