What an API is

An API (Application Programming Interface) is how software talks to other software. A REST API is the most common kind on the web — a set of URLs (endpoints) that let programs get and change data over HTTP. Every app you use (weather, maps, social) is powered by APIs. This course builds a real REST API in Python — starting from plain functions, then a framework. Let's understand what an API is.

What an API does

An API is a contract between programs: the client sends a request ("get me the list of products", "create a new order"), and the server sends back a response (the data, or a confirmation). The API defines what requests are possible — like a menu. A REST API does this over HTTP (the web's protocol), using URLs to identify things and HTTP methods to say what to do. So a program (a website, a mobile app, another server) can fetch and change data on your server through well-defined endpoints. APIs are how modern software is connected.

REST: resources as URLs

REST (Representational State Transfer) organizes an API around resources — the "things" your app manages (books, users, orders). Each resource type has a URL (like /books), and you act on it with HTTP methods (GET to read, POST to create, etc.). So GET /books lists books, GET /books/5 gets one book, POST /books creates one. This resource-oriented, URL-based design is what makes an API "RESTful" — it's predictable and consistent. Notice the pattern: a collection URL (/books) and individual URLs (/books/5). This structure is the heart of REST.

Why build APIs?

APIs power everything:

• Mobile & web apps need a backend API to store and fetch data (your app talks to your API).
• Integrations — services connect via APIs (payment, email, maps).
• Microservices — big systems are built from services talking via APIs.
• Data access — APIs expose data for others (or your own apps) to use.

If you're building any app with a backend, you're building an API. Learning to build REST APIs is a core backend skill — it's how the server side of apps works. This course teaches it hands-on in Python.

How this course works

This course builds an API in two stages. Stage 1: build the API's core logic as plain Python functions — handlers that take a request and return a response (data + status code), backed by an in-memory data store. This teaches REST concepts clearly, and runs live in these lessons! Stage 2: wrap that logic in a real web framework (Flask, FastAPI) that serves actual HTTP requests. This approach separates the concepts (which are framework-independent) from the plumbing (the framework). You'll deeply understand what an API does before adding the how. Let's build.

The mistake beginners make

Thinking an API is complicated framework magic — at its core, an API is just functions that take requests and return responses. Understanding that simple core (which we'll build as plain Python) makes frameworks easy later. Also, confusing the API (the server providing data) with the client (the app consuming it) — you're building the server side. And not grasping the resource/URL/method structure of REST (the key organizing idea). An API is how programs request data/actions from your server; REST organizes it around resources (URLs) and HTTP methods. We'll build the core as functions, then add a framework.

Your turn

Your turn

1. Understand an API: a contract where a client sends requests and a server sends responses (defined endpoints).
2. Grasp REST: organizing the API around RESOURCES (things) with URLs (/books, /books/5) and HTTP methods.
3. See the course plan: build the API core as plain Python functions (runnable), then wrap it in a framework (Flask/FastAPI).

Key points

• An API is a contract: a client sends REQUESTS (get/change data), the server sends RESPONSES — it defines what requests are possible.
• A REST API works over HTTP, organized around RESOURCES with URLs (/books = collection, /books/5 = one) and HTTP methods (GET/POST/etc.).
• APIs power apps (mobile/web backends), integrations, and microservices — building REST APIs is a core backend skill.
• This course builds the API CORE as plain Python functions (handlers returning data + status, runnable live), THEN wraps it in a framework.