Different Options That Emerged Over Time

Making an API call used to mean writing a precise line in a terminal. Over the next two decades, visual forms, no-code automation, shorter languages, and live playgrounds each took a piece of that friction away. The end result is the documentation page itself: you fill in a form, it writes the cURL, you click Try It, and it hands you production-ready code. None of the older options went away — they stacked. Below they're grouped into the four eras they appeared in.

The whole page at a glance

Four eras, oldest first. Every option still sends the same kind of request — what changed is who could send it, and how much they had to type. Click any name to jump to its card.

  1. The Code-Only Era

    Software calling software. Engineers, a terminal, and raw data.

  2. Tools & No-Code Explosion

    Visual wrappers sit between you and the API. Non-developers get in.

  3. Unified Interactive Documentation

    The docs page absorbs the form, the cURL, and the live Try It.

Whichever era you start in, the call underneath is the same shape: where to send it, what to do, proof you're allowed, sometimes the data to change — and an answer that comes back. The Anatomy of an API Call takes those five parts apart.

Phase 1 (Pre-2010): The Code-Only Era

Core theme: Software calling software

For the earliest part of the web's history, interacting with an API was a highly technical task restricted to engineers. If you wanted to fetch data from a server or trigger an action, there were no visual interfaces or shortcuts.

The mechanism

Calls lived strictly inside the software itself. Developers used terminal commands or custom scripts to make server-to-server connections.

The breakthroughs

The birth of cURL (1997) introduced a universal, single-line text shorthand for describing an API call. Shortly after, AJAX (1999) allowed web pages to silently request data from servers in the background without needing to reload the entire page.

Experience level needed

High-friction. To test a single idea, a developer had to open a terminal, write a precise line of syntax, and stare at strings of raw data.

cURL (command line)

LOW CODEDevelopers

One line of text you paste into your computer's terminal — the plain window that runs typed commands. It says 'ask this web address for this thing, and send along this password', then prints the answer. It's already on almost every computer, which is why it's the standard way to hand someone an exact request without asking them to install anything.

See code example
curl https://api.duckbuddy.com/v1/me \
  -H "Authorization: Bearer <token>"
Learn more

Browser address bar

NO CODEAnyone

Type a web address into your browser and press Enter. The browser asks that address for information and prints whatever it sends back, as plain text on the page. It's the same thing that happens when you click a link — except here you're going straight to the source instead of waiting for someone else's website to do it for you.

See code example
https://api.duckbuddy.com/profiles
  ?city=Rome&hobby=hiking
Learn more

Phase 2 (2010–2015): The Separation of Tools & No-Code Explosion

Core theme: Abstracting the code

As the modern mobile and cloud ecosystems exploded, companies needed an easier way to test APIs, and non-programmers wanted to use them to automate tasks. The industry responded by putting visual wrappers over raw code.

The mechanism

Independent, third-party applications were built to sit between the user and the API.

The breakthroughs

Postman (2012) launched, replacing dense command lines with a clean, visual browser-like form. Simultaneously, consumer and enterprise automation tools like IFTTT (2010), Zapier (2011), and Make (2012) arrived. Instead of programming, users could link apps together by clicking pre-built blocks.

Experience level needed

Disjointed but accessible. Non-programmers could finally use APIs, but a gap remained: you still had to read static, text-heavy documentation on a company's website, copy the instructions, and paste them into a separate app (like Postman or Zapier) to make it work.

Postman / Insomnia

NO CODETesters, PMs, devs

Free apps you install on your computer that turn an API call into a form. You type the web address into a box, pick the action from a menu, add a password if one's needed, then press Send and read the answer in the window below. Your requests are saved, so tomorrow you press Send again instead of starting over — and you can hand the whole saved request to a colleague.

See code example
POST https://api.duckbuddy.com/connect
Body → { "toUserId": "abc123" }
Learn more

Zapier / Make / n8n / IFTTT / Power Automate

NO CODEOps & marketing

Automation services that make the calls on your behalf. You pick from lists — 'when this happens, do that' — and never type anything that looks like programming. Zapier and Make are the big marketplaces, with thousands of apps to choose from; n8n is the open-source one you can run on your own server; IFTTT is the simplest, aimed at home and personal gadgets; Power Automate is Microsoft's, built for Office 365 and office paperwork. Because the rule lives on their servers, not your laptop, it keeps making calls all day and night whether your computer is open or not.

See code example
Zapier: new member → Slack post
Power Automate: email → OneDrive
IFTTT: home below 40°F → alert me
Learn more

Phase 3 (2015–2020): Language Optimization & Interactive Playgrounds

Core theme: Elevating the developer experience (DX)

By the mid-2010s, tech companies realized that friction in documentation was turning developers away. The language used to make calls became easier, and documentation began to offer live feedback loops.

The mechanism

Web browsers and native programming languages optimized their code to be incredibly simple, while new API styles challenged traditional architectures.

The breakthroughs

JavaScript introduced fetch() (2015), making browser-based requests clean and native. Python's requests library (2011, widely adopted through the 2010s) made backend work read like plain English. Most notably, GraphQL playgrounds arrived, proving that developers loved having a live, in-browser scratchpad where they could type a query and see results instantly.

Experience level needed

Highly optimized. Writing a production-ready call shrank from dozens of lines of complex setup code down to a single, readable line.

JavaScript fetch()

CODEWeb developers

The built-in way a website asks for a little more information without reloading the page. Every browser already has it — there's nothing to install. When you click a filter and the list quietly changes underneath, that's the page going off, fetching a new list, and redrawing itself in place.

See code example
const res = await fetch("/api/profiles");
const list = await res.json();
Learn more

Axios (JavaScript library)

CODEWeb developers

A helper library that sits between a website and the API and does the untidy work the built-in method leaves to you: it turns the raw answer into something usable, gives up politely if the internet is too slow, and remembers to attach your login to every single request instead of leaving that to be typed each time.

See code example
const { data } = await axios.get(
  "/api/profiles",
  { params: { city: "Rome" } }
);
Learn more

Python requests

CODEData & backend

The standard way to make an API call from a short Python program — the language people reach for when they want to gather information, tidy it up and save the result. There's usually no screen involved: a small program runs, collects what it needs from a few places, and leaves the answer somewhere you'll read it.

See code example
import requests
url = "https://api.duckbuddy.com/people"
r = requests.get(url)
print(r.json())
Learn more

GraphQL playground

LOW CODEDevelopers

A web page with an editor where a developer types what they'd like and presses Run, and the answer appears underneath — with suggestions popping up as they type, so they can discover what's available without reading a manual first. It's a testing ground for a style of API where you ask for exactly the pieces you want, rather than being handed a whole page of them.

See code example
{ profile(id: "abc123") {
    name
    hobbies
  } }
Learn more

Official SDKs

CODEDevelopers

Ready-made toolkits published by the company that actually runs the service — Stripe for card payments, OpenAI for chatbots, Twilio for text messages. Instead of you building the raw request, the company hands you a small library of named functions that already know how to log in, retry when something fails, and speak that service properly.

See code example
const reply = await openai.chat
  .completions.create({
    model: "gpt-5"
  });
Learn more

WebSocket client

CODEReal-time apps

Instead of sending a separate question every time you want to know if anything is new, this opens a line to the server and leaves it open, so the server can push things to you the moment they happen. Browsers have it built in. It's what makes chat feel instant and 'online now' dots honest.

See code example
const ws = new WebSocket(
  "wss://chat.duckbuddy.com/rooms/rome"
);
ws.onmessage = (e) => {
  console.log(e.data);
};
Learn more

Phase 4 (Modern Era): The Unified Interactive Documentation

Core theme: The explorer absorbs the ecosystem

Today we live in the era of platforms like ReadMe, Mintlify, Swagger UI, and Scalar. These tools took the benefits of the previous three eras — the visual forms of Postman, the universal shorthand of cURL, and the live feedback of GraphQL playgrounds — and fused them directly into the company's documentation page.

The mechanism

Documentation is no longer a static textbook; it is a live software application powered by an OpenAPI / Swagger blueprint file.

Experience level needed

The ultimate pipeline. On a single screen, a user inputs their parameters into a visual form → the page instantly writes the cURL shorthand → the user clicks Try It to see live data → and the page auto-generates production-ready JavaScript fetch() or Python code to copy straight into an app.

Interactive docs

NO CODEAnyone reading the docs

Documentation is no longer a static textbook. Platforms like ReadMe, Mintlify, Swagger UI and Scalar turned the company's API page into a live app: you fill in a form, the page writes the cURL, you click Try It to see live data, and it auto-generates JavaScript fetch() or Python to copy into an app. This is the end result of the three eras above — Postman's form, cURL's shorthand, and the playground's live feedback, fused onto one screen.

See code example
Fill in a form  →  page writes cURL
  →  click Try It  →  copy fetch() / Python
Learn more

Example of using an API interactive Doc on a company's website or in their product, using Mintlify

NO CODEAnyone reading the docs

Mintlify turns a company's OpenAPI file into a live documentation site. You don't install anything: you open their docs, browse every call they offer, fill in a form, and press Try it. Here's the walk-through on a typical company page.

  1. Open the docs. Look for docs.company.com, or a Developers / API link in the footer.
  2. Click API Reference in the left sidebar. Mintlify builds this list from the OpenAPI file, so it is the full menu of calls.
  3. Pick a call — for example GET /profiles. The page shows what it needs, what it returns, and a playground on the right.
  4. Add an API key if the page asks for one (usually from your account settings), then fill in the form fields.
  5. Click Try it. Mintlify sends a real request and prints the live response underneath.
  6. Copy the code it generated — cURL, JavaScript, or Python — if you want to reuse the same call in an app or a script.
See code example
docs.duckbuddy.com
  → API Reference → GET /profiles
  → fill city=Rome  →  Try it
  → copy fetch() / Python
Learn more

None of them replaced the last one — they stacked. A developer still uses cURL. A marketer still uses Zapier. The new thing is that both can start on the same documentation page.

Where to Go Next

Keep going in order, or jump to any page from the top menu.