liveBook · Manning

REST

Also called representational state transfer, RESTful

REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.

How 30 Manning books explain it

Learn Go with Pocket-Sized Projects

REST is an architectural style that defines resources and interactions with them through uniform representations and HTTP semantics.

How it is used
Uses REST to expose a game service to remote clients through HTTP endpoints.
How deep it goes
Defines REST and implements routing, response handling, and tests for game creation; leaves deployment out of scope.
Examples
Uses a Gordle game-creation endpoint, a JSON game response, curl requests, and a handler test.
What you can do after
Apply REST through Go's net/http to define and test a resource-creation endpoint.

Read how Learn Go with Pocket-Sized Projects explains REST →

Rust Servers, Services, and Apps

REST is an architectural style for networked applications that models functionality as interactions with identifiable resources.

How it is used
Uses REST to expose course creation and retrieval to web or mobile clients over HTTP.
How deep it goes
Defines REST constraints and works through Actix routes, handlers, shared state, and tests; stops short of exhaustive failure testing.
Examples
Builds a health check and three course endpoints, then exercises creation with curl and retrieval with a browser and tests.
What you can do after
Build it from scratch: implement and test a small RESTful course service with Actix Web and in-memory state.

Read how Rust Servers, Services, and Apps explains REST →

Building Web APIs with ASP.NET Core

REST is an architectural style for network-based applications that uses standardized operations and resource representations over a uniform interface.

How it is used
Guides the design of a board-game web API that exchanges and manipulates resource data through HTTP.
How deep it goes
Moves from HTTP method meanings and guiding constraints to ASP.NET Core configuration and response design, without dwelling on theory.
Examples
Uses a board-game API and ASP.NET Core response caching, CORS, and hypermedia responses as implementation contexts.
What you can do after
Apply it via ASP.NET Core to make a board-game API more RESTful and evaluate when REST’s fetching trade-offs warrant an alternative.

Read how Building Web APIs with ASP.NET Core explains REST →

The Design of Web APIs, Second Edition

The REST architectural style is a distributed-systems style that emphasizes stateless interactions, resource representations, layered components, and a uniform interface.

How it is used
Turns consumer-facing capabilities into resource-based HTTP requests and responses while guiding distributed-system design.
How deep it goes
Defines six architectural constraints and outlines an interface-design sequence, while deferring detailed caching, stateless call flows, and interoperability treatments.
Examples
Uses a product search with GET /products and contrasts DELETE /products/123 with a misleading GET-based deletion.
What you can do after
Build it from scratch by mapping capabilities to resources and HTTP, then evaluate existing APIs against REST principles.

Read how The Design of Web APIs, Second Edition explains REST →

ASP.NET Core in Action, 3e

A RESTful API is a web API designed around REST constraints and resource-oriented HTTP interactions.

How it is used
Deploys REST as an HTTP API style for mobile apps, single-page applications, and other clients.
How deep it goes
Defines stateless HTTP interactions and maps common verbs to operations, but does not detail broader REST constraints.
Examples
Uses a C# MapGet route, HTTP verb mappings, and Postman, Rider HTTP Client, or Swagger UI for testing.
What you can do after
Apply it via ASP.NET Core minimal APIs by assigning resource operations to semantically appropriate HTTP verbs.

Read how ASP.NET Core in Action, 3e explains REST →

Building User-Friendly DSLs

A REST API is an HTTP-based interface whose resources and operations follow the constraints and conventions of Representational State Transfer.

How it is used
Uses HTTP resources to persist and transport AST data between a frontend editor and a backend.
How deep it goes
Implements one resource with GET and PUT, then defers broader API complexity while addressing JSON storage and AST references.
Examples
Demonstrates /contents, a persisted contents.json file, Express handlers, frontend fetch calls, and a serialized Rental AST.
What you can do after
Builds a minimal Express REST API that reads and writes JSON, then connects a frontend client to its resource.

Read how Building User-Friendly DSLs explains REST →

Acing the CCNA Exam: Volume 2 Advanced Networking and Security

Representational state transfer is an architectural style for distributed systems that models interactions around resources and their representations.

How it is used
Connects software applications and commonly supplies the SDN northbound interface for network automation.
How deep it goes
Defines six constraints and explains client-server and stateless behavior, while deferring detailed treatment of all six constraints.
Examples
Uses HTTP requests and responses, CRUD method mappings, response codes, SDN northbound communication, and Cisco Catalyst Center API calls.
What you can do after
Evaluate REST-based APIs using authentication, CRUD operations, HTTP verbs, data encoding, and response behavior.

Read how Acing the CCNA Exam: Volume 2 Advanced Networking and Security explains REST →

Fast by Default

REST is an architectural style for networked interfaces that models interactions as operations on identifiable resources using standardized web semantics.

How it is used
Uses resource-oriented endpoints to structure backend APIs and deliver data through familiar web infrastructure.
How deep it goes
Explains endpoint structure and request costs, but stops short of implementation code or protocol internals.
Examples
Uses user and post endpoints plus GitHub's four-request pull-request display to show resource access and round-trip costs.
What you can do after
Evaluate REST API designs by counting round trips, inspecting payloads, and comparing alternatives for the client workload.

Read how Fast by Default explains REST →

Apache Kafka in Action

REST is an architectural style for networked applications that represents resources and accesses them through stateless, uniform interfaces.

How it is used
Uses REST for request-driven service communication and for administering Kafka Connect connectors.
How deep it goes
Explains resource-oriented requests and works through connector operations, but does not develop REST's architectural constraints.
Examples
Demonstrates curl requests that create a customer-file connector, change its source path, and pause or restart it.
What you can do after
Operate/configure it through Kafka Connect's REST API to create, update, inspect, pause, resume, delete, and restart connectors.

Read how Apache Kafka in Action explains REST →

Microservices Patterns, Second Edition

An architectural style for networked systems defined by constraints on interactions between components and resources.

How it is used
Provides interprocess communication for microservices, usually through HTTP-based resource APIs.
How deep it goes
Defines resources, URLs, representations, and HTTP verbs, and introduces a REST maturity model.
Examples
Uses Order creation and retrieval endpoints to illustrate resource operations.
What you can do after
Apply REST by modeling business objects as resources and mapping retrieval, creation, and updates to HTTP requests.

Read how Microservices Patterns, Second Edition explains REST →

Learn Docker in a Month of Lunches, Second Edition

A REST API is an HTTP interface that exposes resources and operations according to the principles of representational state transfer.

How it is used
Uses HTTP interfaces to expose and manage resources for applications, Docker components, and registries.
How deep it goes
Explains client-server interaction and practical request workflows, but does not detail REST constraints or HTTP semantics.
Examples
Demonstrates a cached NASA image service and registry operations for listing tags, reading manifests, and deleting images.
What you can do after
Apply it via Docker CLI workflows and documented registry requests to inspect and manage container resources.

Read how Learn Docker in a Month of Lunches, Second Edition explains REST →

Deep Learning with Python, Third Edition

How it is used
Deploys model inference online so applications can request predictions through an API.
How deep it goes
Shows export and inference workflows plus connectivity and latency trade-offs, but does not detail API design.
Examples
Uses Keras export examples for TensorFlow SavedModel and ONNX inference.
What you can do after
Apply Keras export with TensorFlow Serving or ONNX to serve model predictions.

Read how Deep Learning with Python, Third Edition explains REST →

Deep Learning with R, Third Edition

A REST API is a web interface that exposes resources or operations through HTTP requests following REST architectural conventions.

How it is used
Deploys inference models as online prediction services for applications that can reliably access the internet.
How deep it goes
Explains exporting weights and computation graphs, then serving them through TensorFlow Serving or ONNX; it does not detail request schemas.
Examples
Demonstrates Keras SavedModel export, TensorFlow artifact loading, ONNX Runtime execution, and Posit Connect deployment.
What you can do after
Apply it via TensorFlow Serving, ONNX Runtime, or Posit Connect to expose a trained model for prediction.

Read how Deep Learning with R, Third Edition explains REST →

Amazon Web Services in Action, Third Edition: An in-depth guide to AWS

A REST API is a web API that exposes resources and operations through HTTP according to REST architectural constraints.

How it is used
Explains how web applications expose resource operations and how AWS services are reached through HTTP APIs.
How deep it goes
Implements three Express routes and their AWS interactions, but leaves framework internals and broader REST constraints unexplained.
Examples
Uses S3 listing requests and an Imagery image-processing service with creation, status, and upload routes.
What you can do after
Apply it via Node.js and Express to build routes backed by DynamoDB and S3.

Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains REST →

Spring AI in Action

A REST service is a network service that exposes functionality or resources through REST-style HTTP endpoints.

How it is used
Deploys REST endpoints as the application boundary for submitting questions and returning AI-generated answers.
How deep it goes
Demonstrates endpoint implementation with Spring annotations, request records, dependency injection, service delegation, and JSON output.
Examples
Uses a POST /ask controller with Question and Answer Java records to demonstrate an AI-backed endpoint.
What you can do after
Build an AI-backed REST endpoint that accepts JSON questions and returns JSON answers through Spring components.

Read how Spring AI in Action explains REST →

Kafka Streams in Action, Second Edition

A REST API is an HTTP-based interface that exposes resources and operations through conventional web representations and methods.

How it is used
Uses HTTP requests to register, inspect, and test schemas while developing Kafka producers and consumers.
How deep it goes
Explains request routing and Kafka-backed persistence, then demonstrates basic curl commands without detailing REST endpoint internals.
Examples
Demonstrates curl and jq commands for registering an Avengers Avro schema and retrieving subjects and versions.
What you can do after
Apply it via curl and jq to register schemas, list subjects, and retrieve schema versions.

Read how Kafka Streams in Action, Second Edition explains REST →

Grokking Software Architecture

Representational State Transfer is an architectural style for networked applications based on resources, a uniform interface, and stateless interactions.

How it is used
Structures public APIs as resource-based contracts for clients and services to interact across network boundaries.
How deep it goes
Defines resource URLs and core constraints, then illustrates response payloads and verb behavior under repeated requests.
Examples
Uses a vending-machine analogy, a product response, and order requests to illustrate resources, payloads, and retries.
What you can do after
Apply it by modeling resources at URLs and choosing standard verbs with request retries and response caching in mind.

Read how Grokking Software Architecture explains REST →

Latency

A REST API is an HTTP-based application programming interface that exposes resources and operations according to REST architectural constraints.

How it is used
Uses REST APIs to connect HTTP request handling with database access and quantify deployment latency.
How deep it goes
Builds a runnable endpoint, handler, database integration, and benchmark, but does not detail REST architectural constraints.
Examples
Uses a GET /hello endpoint backed by PostgreSQL or SQLite, then compares latency distributions with wrk and an eCDF plot.
What you can do after
Build it from scratch with Actix Web, connect PostgreSQL or SQLite, and measure endpoint latency with wrk.

Read how Latency explains REST →

ActiveMQ in Action

REST (Representational State Transfer) is an architectural style for distributed systems that organizes interactions around resources and a uniform interface.

How it is used
Uses REST to expose ActiveMQ broker destinations and messages to HTTP clients.
How deep it goes
Explains resource addressing and HTTP methods, then shows broker endpoints and servlet configuration rather than a full account of REST constraints.
Examples
Uses a Java producer, an HTTP consumer, and wget and curl calls to a stock topic.
What you can do after
Apply REST via the ActiveMQ REST API to send and receive broker messages over HTTP.

Read how ActiveMQ in Action explains REST →

Software Engineering for Data Scientists

A REST API is an application programming interface organized around the constraints and resource-oriented interactions of Representational State Transfer.

How it is used
Deploys models behind a service so clients can request predictions from another server or environment.
How deep it goes
Defines statelessness, HTTPS transport, and request methods, but does not detail REST implementation internals.
Examples
Uses Google search, customer-churn predictions, database feature lookup, and cross-language API requests as examples.
What you can do after
Apply it via HTTPS GET, POST, PUT, PATCH, and DELETE requests to interact with remote services and models.

Read how Software Engineering for Data Scientists explains REST →

Go by Example

REST is an architectural approach for designing networked resources and interactions through uniform operations, commonly over HTTP.

How it is used
Structures a maintainable HTTP microservice by separating REST handlers from core service logic.
How deep it goes
Explains REST through HTTP methods, handler boundaries, service calls, and API tests.
Examples
Uses a link-shortening API with POST-based shortening and GET-based resolution redirects.
What you can do after
Build it from scratch and test it with Go's standard-library http and httptest packages.

Read how Go by Example explains REST →

Data Pipelines with Apache Airflow, Second Edition

A REST API is an HTTP-based application programming interface that exposes resources and operations through stateless web requests.

How it is used
Uses REST APIs as external data sources and event-related inputs for Airflow workflows.
How deep it goes
Explains endpoints, authentication, parameters, response records, and request-size limits, but stops short of general REST design.
Examples
Demonstrates a Citi Bike API returning ride coordinates and timestamps through configurable recent-period endpoints.
What you can do after
Apply it via curl by authenticating, selecting an endpoint interval, and retrieving records for pipeline processing.

Read how Data Pipelines with Apache Airflow, Second Edition explains REST →

Build Financial Software with Generative AI (From Scratch)

REST is an architectural style for networked systems that uses resource-oriented representations and standard operations, commonly over HTTP.

How it is used
Supports API-driven design for interactions among distributed software components, microservices, systems, and packages.
How deep it goes
Introduces REST through HTTP methods and API design tradeoffs, without detailing its architectural constraints.
Examples
Uses FastAPI endpoints, pagination, asynchronous processing, and APIs for ACH processing and dashboard functionality.
What you can do after
Apply FastAPI to build APIs and document them through OpenAPI for financial application features.

Read how Build Financial Software with Generative AI (From Scratch) explains REST →

Pro ASP.NET Core 7, Tenth Edition

REST, or Representational State Transfer, is an architectural style for networked systems in which resources are identified and manipulated through representations and standardized operations.

How it is used
Provides application data to clients through HTTP endpoints, commonly supporting rich client-side applications.
How deep it goes
Defines the URL-and-method model and common verb conventions, but stops short of prescribing a complete REST specification.
Examples
Uses /api/products/1 to identify a product and GET, POST, PUT, PATCH, and DELETE to illustrate operations.
What you can do after
Build RESTful endpoints by pairing URLs with HTTP methods and selecting controller or minimal-API implementations.

Read how Pro ASP.NET Core 7, Tenth Edition explains REST →

Spring Start Here, Second Edition

REST is an architectural style for designing networked resources and their interactions through representations and standardized operations.

How it is used
Connects applications through HTTP endpoints that expose server functionality and return data to clients.
How deep it goes
Explains endpoint mapping, direct responses, request inputs, status and headers, and exception handling.
Examples
Uses web-client, mobile-app, and backend-service communication as endpoint scenarios.
What you can do after
Build Spring REST endpoints that handle request data, return response bodies, and manage status, headers, or exceptions.

Read how Spring Start Here, Second Edition explains REST →

Spring Microservices in Action

REST is an architectural style for networked systems in which resources are identified and manipulated through representations and a uniform interface.

How it is used
Guides microservice interface design toward consistent, intuitive communication between services.
How deep it goes
Explains HTTP verbs, resource-oriented URIs, JSON, and status-code conventions without detailing REST internals.
Examples
Uses GET, POST, PUT, and DELETE, resource-oriented URIs, JSON payloads, and HTTP status codes as interface conventions.
What you can do after
Apply REST-style interface design with HTTP verbs, resource URIs, JSON payloads, and consistent status codes.

Read how Spring Microservices in Action explains REST →

Pro Angular 16

REST is an architectural approach for designing web services around resources, URLs, and HTTP operations.

How it is used
Uses HTTP requests and resource URLs to deliver application data through web services.
How deep it goes
Defines resource selection and HTTP operations, demonstrates standard combinations, and cautions that implementations vary without specifying a formal standard.
Examples
Uses products and orders collections, the /products/2 endpoint, JSON responses, and json-server middleware.
What you can do after
Apply via HTTP requests by selecting resource URLs, choosing verbs, and supplying JSON request bodies where required.

Read how Pro Angular 16 explains REST →

Digital Twins in Action

A REST API is a web interface that exposes resources and operations through HTTP methods and resource-oriented URLs.

How it is used
Uses REST to integrate external imagery and expose digital-twin resources over HTTP.
How deep it goes
Works through resource requests and an imagery retrieval listing, without detailing the full set of REST constraints.
Examples
Uses Lake Kariba satellite imagery and second-floor room temperatures to illustrate API retrieval.
What you can do after
Evaluate REST's request and response tradeoffs for interconnected digital-twin data.

Read how Digital Twins in Action explains REST →

Investing for Programmers

A REST API is a web interface that exposes resources and operations through the conventions of the Representational State Transfer architectural style.

How it is used
Connects Python automation to Notion by creating pages and writing generated investment-research content.
How deep it goes
Explains payload construction, HTTP methods, status checks, identifiers, and chunked writes, but does not develop REST architecture broadly.
Examples
Uses Notion page creation, block updates, title properties, JSON dictionaries, and 2,000-character content chunks.
What you can do after
Apply it via Python requests to create resources, update content, validate responses, and handle service size limits.

Read how Investing for Programmers explains REST →

Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more

A REST API is a network interface that exposes resources and operations through HTTP using representational state transfer conventions.

How it is used
Connects remote clients, scripts, CI/CD systems, GUI tools, and compose workflows to Podman containers.
How deep it goes
Defines socket activation, API modes, bindings, and SSH communication without detailing request formats.
Examples
Demonstrates docker-compose, Python bindings, podman --remote, and podman system connect workflows.
What you can do after
Operate remote Podman through REST clients, Python bindings, Docker-compatible tools, or SSH connections.

Read how Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more explains REST →

Also covered in

What to know first

Related concepts

Questions about REST

What is REST?

REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.

Which Manning books explain REST?

Learn Go with Pocket-Sized Projects, Rust Servers, Services, and Apps, Building Web APIs with ASP.NET Core, The Design of Web APIs, Second Edition, ASP.NET Core in Action, 3e, Building User-Friendly DSLs, Acing the CCNA Exam: Volume 2 Advanced Networking and Security, Fast by Default and 22 more.

What should I know before learning REST?

Manning books that teach REST usually introduce HTTP, JSON, contract and JavaScript first.

What is the difference between REST and GraphQL?

REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability. GraphQL is a query language and execution specification for APIs that lets clients request and manipulate data through a schema.

What is REST a kind of?

REST is a kind of web service. A web service is a network-accessible software service that exposes functionality or data through a defined interface using web protocols.

What is REST also called?

REST is also called representational state transfer or RESTful.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.