APIs for Beginners
by Sergey Okinchuk

APIs for Beginners

Welcome

API is the word in every job posting and every meeting that everyone quietly pretends to understand. This course retires the pretending. You will learn what an API actually is — a promise between programs, written down in plain text — and then genuinely use one: read the documentation, get a key, send requests with tools already on your computer, and read the answers. Then the part that separates users from bystanders: errors and whose side they are on, retries that do not double-book, pagination, rate limits, versioning, and the API that calls you back. No programming, anywhere in the book. By the last chapter, "works with APIs" is simply true of you.

≈8.5 hours to complete Knowledge check on every topic

About This Course

Everyone is expected to know what an API is, and almost nobody was ever taught. The word shows up in job descriptions for analysts, testers, managers, and marketers; products are bought and sold on "has an API"; meetings pivot on integrations — and the people nodding along mostly picture something between a cable and a spell. This course takes the honest path: it explains the thing itself, at a beginner's pace, and then has you use it, because using one is the only cure for the nod. The claim the whole book stands on: using an API is not programming. It is asking well — and asking well can be taught to anyone who can read.

The course follows Vera, mobility coordinator for the city of Riverport, through one recurring piece of real work: the Thursday report on the city's bike-share, which she currently assembles by hand, station by station, from an app. Chapter by chapter, the report learns to fill itself — through documentation read cold, a key kept safe, requests sent deliberately, errors triaged calmly, and eventually news that arrives on its own. Her arc is the course's promise: a non-programmer who ends up genuinely fluent at the counter where software asks software for things.

Who This Is For

Anyone whose work touches software from the outside: analysts pulling data, testers who keep hearing "just check the API," product and project people who sit in integration meetings, support staff, no-code builders, career-switchers deciding what to learn first. And anyone who has typed the word into a search bar, read the first paragraph, and quietly closed the tab. No technical background is assumed at any point. Every term is defined the first time it appears, and the two tools used all book — the web browser and one small command — are already on your computer.

It is not a course about building APIs — designing them, implementing them, securing them from the inside — which is a different job this catalogue will serve with a different book. And it is not about testing them systematically, which is already served: QA & Software Testing for Beginners teaches the tester's craft, and its API chapter reads like this book's mirror world. Here you are always the guest at the counter, never the architect behind it — and the book takes pride in how much that guest can do.

What You Should Already Know

  • How to use a computer, a browser, and everyday apps — user-level, nothing more
  • No programming and no command-line experience — the one command this book uses is introduced from zero, gently
  • No networking knowledge — the internet's plumbing stays in its own course; here you only read addresses, not packets
  • Curiosity about what actually happens when an app "talks to" something

How the Course Is Built

Eleven chapters in five movements. What it is (Chapter 1): the idea of the promise between programs, and the bike-share city the whole book runs on. The language (Chapters 2–4): HTTP read fluently, your first requests sent, JSON read without drowning. The rules of entry (Chapters 5–6): keys and authentication, and documentation raided like a professional. When reality bites (Chapters 7–9): errors and whose side they are on, real-world data with its pages and limits and versions, and the APIs that call you back. The map (Chapters 10–11): the wider world — GraphQL, gRPC, realtime, the enterprise past — and the field trip to real public APIs that proves the skill transferred.

Every topic has the same gentle shape: a hook from Vera's world, the idea built step by step, one everyday comparison where it earns its place, the mix-ups people actually make, why it matters, and a short knowledge check. Patient, but it keeps moving — you are here to learn, not to be slowed down.

The promise, not the magic
Every mechanism is taught from the same root idea: an API is a written promise between programs. Keys, versions, status codes, webhooks — each is a clause, and clauses can be read.
One city, all the way through
Riverport's bike-share accumulates chapter by chapter — the same stations, the same rush hour, the same report — so every new idea lands on a story you already know.
Honest, never hyped
What APIs genuinely promise, how they fail, and what the fine print costs — stated plainly. Errors are treated as messages to read, not disasters to fear. Nothing here will need unlearning.
Mechanisms over products
The fictional API keeps every promise a real one makes, so the book barely ages. Real products appear on a handful of clearly marked pages, where meeting the real world is the point.

Chapter Map

Chapter 1
What an API Actually Is
The nod, retired: an agreed way for programs to ask and answer, written down where anyone can read it. The ten APIs before breakfast, client and server, why the doors exist — and meet Tandem.
Chapter 2
The Language of HTTP
The URL's four rooms, the request's three parts, the response that mirrors it, five verbs with real meanings, and the three-digit verdicts read at a glance. Pure reading fluency.
Chapter 3
Your First Requests
The browser was an API client all along. JSON in the address bar, the developer panel that shows every request an app makes, curl — one tool, every system — and your first POST.
Chapter 4
Reading JSON
The whole grammar in one page — six kinds of value, and that is all. Nesting, the strategy for big responses (find the array, read one element), and the formats that are not JSON.
Chapter 5
Keys and Authentication
Why the API wants to know you, the key that turns 401 into 200, why that key is a password with a longer name, tokens that expire on purpose, and OAuth without a single dreadful diagram.
Chapter 6
Reading the Documentation
Reference pages are raided, not read: the five-part anatomy every API's docs share, the OpenAPI file behind the familiar look, sandboxes where mistakes are free — and what to do when docs lie.
Chapter 7
When Things Go Wrong
An error is a response with a story. One working request broken five ways, the honest 503, which requests are safe to retry and which double-book — and the checklist that replaces panic.
Chapter 8
Real-World Data
Two hundred and fourteen stations arrive fifty at a time. Pagination, filtering and sorting at the source, the rush-hour rate limit and its counters, cache staleness, and why /v1 is a promise.
Chapter 9
APIs That Call You
Polling and its price, webhooks — the same message shape travelling the other way — the signature that proves who is knocking, and the duplicates and gaps every receiver must expect.
Chapter 10
The Wider World
Recognition, not practice: GraphQL's menu, gRPC's freight rail, WebSocket's open line, SOAP's envelopes still running banks — and the GUI clients that wrap the requests you already speak.
Chapter 11
Where to Go Next
The field trip: real public APIs approached with a four-step ritual. The AI wave as an API story, the builder's and tester's paths onward, and what Vera's Thursday looks like now.

Disclaimer

This course is an independent educational project created and maintained by Sergey Okinchuk. It is provided for learning and reference purposes only.

No affiliation. This course is not affiliated with, sponsored by, endorsed by, or officially connected to any company, product, or organization. Tandem, Riverport, and all characters in this course are fictional; any resemblance to real companies, places, or persons is coincidental.

Trademarks. Product and company names referenced are the property of their respective owners. Use of any name is for identification and educational purposes only and does not imply endorsement.

Educational simplifications. This material teaches durable concepts for understanding, not operational instructions. Explanations are deliberately simplified for learning; where a simplification could mislead, the text flags it. This course is not professional, legal, or financial advice.

Accuracy and currency. The field evolves — tools, products, and practices drift over time. Facts reflect the author's understanding at the time of writing. The course deliberately teaches mechanism over product specifics; always consult authoritative sources for the current state of any tool or service.

No warranty. This material is provided "as is" without warranty of any kind. The author accepts no liability for any loss or damage arising from reliance on the content.