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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- Django in Action
- Architecting an Apache Iceberg Lakehouse
- Practical Automation with PowerShell: Effective scripting from the console to the cloud
- Elasticsearch in Action, Second Edition
- Software Security for Developers
- ScyllaDB in Action
- Machine Learning Platform Engineering
- Kubernetes in Action, Second Edition
- gRPC Microservices in Go
- Java Persistence with Spring Data and Hibernate epub
- Python Concurrency with asyncio
- Shipping Go: Develop, deliver, discuss, design, and go again
What to know first
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- JavaScriptJavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
Related concepts
- HTTPuses · HTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
- GraphQLalternative to · GraphQL is a query language and execution specification for APIs that lets clients request and manipulate data through a schema.
- JSONuses · JSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- gRPCalternative to · gRPC is an open-source remote procedure call framework for defining services and invoking them across process or network boundaries, commonly using Protocol Buffers and HTTP/2.
- web servicekind of · A web service is a network-accessible software service that exposes functionality or data through a defined interface using web protocols.
- client-server architectureuses · Client-server architecture is a distributed computing pattern in which clients request services or resources from servers that provide them.
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.





























