# APIs & Integration

> REST, GraphQL, gRPC, webhooks, and message queues - how systems actually talk to each other.

10 guides.

- [What an API Actually Is](https://themissingmanual.dev/guides/what-an-api-is) _(beginner)_ - An API is a defined way for one program to ask another for something - a contract that says what you can ask and what you'll get back - and this guide builds that mental model from the ground up before you touch any code.
- [HTTP & JSON: the API Building Blocks](https://themissingmanual.dev/guides/http-and-json-api-basics) _(beginner)_ - Every web API is made of two things: HTTP carries the message, JSON carries the data. Learn both well enough to read any API call with confidence.
- [REST APIs, Explained](https://themissingmanual.dev/guides/rest-apis-explained) _(intermediate)_ - The mental model behind the web's dominant API style - things live at URLs, HTTP methods are the verbs you apply to them, and every request stands on its own.
- [Reading API Docs & Using Postman](https://themissingmanual.dev/guides/reading-api-docs-postman) _(beginner)_ - How to go from an unfamiliar API docs page to a working request: read the reference, fire the call in Postman or curl, and read the response - without guessing.
- [GraphQL, Explained](https://themissingmanual.dev/guides/graphql-explained) _(intermediate)_ - What GraphQL actually is, the REST pain it was built to fix, how its typed schema and single endpoint work, and the real trade-offs that tell you when to reach for it and when not to.
- [gRPC, Explained](https://themissingmanual.dev/guides/grpc-explained) _(intermediate)_ - What gRPC actually is - a contract-first way for internal services to call each other fast - how the .proto file, code generation, and HTTP/2 streaming fit together, and the real trade-offs versus REST and GraphQL.
- [Webhooks & Message Queues - Events and Async Integration Beyond Request/Response](https://themissingmanual.dev/guides/webhooks-and-message-queues) _(intermediate)_ - How services talk to each other when one of them isn't waiting for an answer: webhooks let another system call your URL when something happens, and message queues let your own services hand off work to be done later.
- [Versioning & Designing APIs That Last](https://themissingmanual.dev/guides/designing-apis-that-last) _(advanced)_ - An API is a promise to everyone who built on it: what counts as a breaking change, how to evolve without breaking clients (additive-first, then versioning + deprecation), and the durable-API checklist - consistent shapes, pagination, idempotency, rate limits, and great docs.
- [Rate Limits and Retries](https://themissingmanual.dev/guides/rate-limits-and-retries) _(intermediate)_ - Calling a flaky or throttled API without melting it or yourself: 429s, exponential backoff with jitter, idempotency, and circuit breakers.
- [Realtime APIs: WebSockets vs SSE vs Polling](https://themissingmanual.dev/guides/realtime-apis-websockets-sse) _(intermediate)_ - How to push live updates: the real tradeoffs between polling, Server-Sent Events, and WebSockets, and which to reach for when.