REST
74 items tagged with "rest"
Best Practices10
Google API Design Guide
Opinionated REST and gRPC design rules: resource-oriented URIs, plural nouns, pagination, errors.
Microsoft REST API Guidelines
Cross-company REST consistency rules (nouns, verbs, versioning, errors).
Richardson Maturity Model
A four-level model for grading how fully an HTTP API embraces REST, from RPC-style endpoints up to hypermedia controls (HATEOAS).
OpenAPI Specification Best Practices
Guidance for writing accurate, machine-readable OpenAPI documents that describe HTTP APIs and drive docs, client SDKs, mocks, and contract tests.
API-First Design
An approach that treats the API contract as a product designed before implementation, so teams agree on the interface, then build clients and servers in parallel.
Idempotency Keys
A pattern where clients send a unique key with unsafe requests so the server can safely retry without applying the same operation twice, preventing duplicate charges or records.
API Pagination Best Practices
Techniques for returning large result sets in pages without breaking under concurrent writes: offset, cursor (keyset), and page-token pagination, with stable ordering.
Problem Details for HTTP APIs (RFC 9457)
An IETF standard JSON format for machine-readable HTTP error responses, defining fields like type, title, status, detail, and instance for consistent error handling.
API Backward Compatibility
Evolving an API without breaking existing clients by making only additive changes, versioning breaking changes, and deprecating fields gracefully over time.
JSON:API Specification
A convention for building JSON APIs that standardizes resource structure, relationships, pagination, filtering, and sparse fieldsets to reduce bikeshedding and over-fetching.
Patterns5
Request-Reply
Lets a requestor send a message and receive a corresponding response over messaging, combining two one-way channels into a logical two-way exchange.
Pagination
Splits a large result set into smaller pages so APIs and UIs can return and traverse data incrementally instead of loading everything at once.
HATEOAS
Hypermedia as the Engine of Application State: REST responses include links describing available actions, letting clients navigate the API by following links.
Idempotency Key
A client-supplied unique key lets a server detect and dedupe retried requests, so repeated submissions produce the same result exactly once.
API Versioning
Strategies for evolving an API without breaking existing clients, by exposing multiple versions through URLs, headers, or media types.
Anti-Patterns5
Chatty API
An API design that forces clients to make many small round trips to complete one task, harming latency, scalability, and battery life.
Breaking Changes Without Versioning
Changing an API's contract in place without versioning or deprecation, silently breaking existing clients and eroding trust.
Inconsistent API Naming and Conventions
An API where naming, casing, pluralization, error formats, and conventions vary across endpoints, raising the learning curve and integration errors.
Overfetching and Underfetching
Endpoints that return too much data or too little, forcing clients to waste bandwidth or make extra calls to assemble what they need.
Ignoring Idempotency
Designing write operations that cause duplicate effects when retried, so network blips and client retries create double charges or duplicate records.
Tutorials4
Building a GraphQL API from REST Endpoints
Transform your REST API into a GraphQL server with Apollo
How to build a REST API with Amazon API Gateway
Configure Amazon API Gateway routes, stages, and authorizers to expose backend services as a managed REST API.
How to Build a REST API with Best Practices
Design resource-oriented routes, use correct status codes, validate input, handle errors consistently, and version your REST API.
How to Add Cursor-Based Pagination to a REST API
Replace offset pagination with stable cursor pagination, return navigation links, and keep results consistent under concurrent writes.
Blueprints6
EJB to REST Services Blueprint
Replace remote EJB interfaces with HTTP REST services to decouple clients from RMI and enable language-agnostic integration.
SOAP to REST API Modernization Blueprint
Modernize WSDL-based SOAP web services to REST APIs with OpenAPI contracts, JSON payloads, and OAuth 2.0 security.
REST API to GraphQL Federation Blueprint
Migrate a sprawling set of REST endpoints to a federated GraphQL graph so clients fetch exactly what they need from one typed endpoint.
REST to gRPC for Internal Services Blueprint
Replace JSON-over-HTTP calls between internal microservices with gRPC and Protocol Buffers for lower latency and strongly typed contracts.
Monolithic API to API Gateway Blueprint
Front a monolithic API with an API gateway to centralize auth, rate limiting, routing, and observability before decomposing services.
Ad-Hoc REST Versioning to API-First Contracts Blueprint
Move from unmanaged REST API changes to an API-first workflow with OpenAPI contracts, contract testing, and a backward-compatibility policy.
Reference Architectures3
API Gateway with Backends-for-Frontends
An edge API gateway fronting channel-specific BFF services that aggregate microservices for web, mobile, and partner clients.
Enterprise API Management Platform
A full API management platform providing a developer portal, gateway, monetization, and lifecycle governance for internal and partner APIs.
Cloud-Native REST API Platform
A versioned, API-first REST platform with contract-driven development, gateway policies, and managed data services on GCP.
Playbooks4
API Modernization Playbook
Transform legacy APIs to modern REST or GraphQL
API-First Transformation Program Playbook
An organization-wide program to adopt API-first design with contract governance, an API gateway, and a developer portal.
API-First Design Program Playbook
A program to establish API-first practices across teams using OpenAPI contracts, mock-driven development, and contract testing.
REST API Versioning and Deprecation Playbook
A program to establish disciplined REST API versioning, backward compatibility, and graceful deprecation across a portfolio.
Checklists5
API-First Design Review Checklist
Review an API design before implementation to ensure contract, versioning, and consistency standards are met up front.
API Design Review Checklist
Review items for evaluating a new or changed HTTP API against design, consistency, and developer-experience standards.
API Versioning and Deprecation Checklist
Verification items for introducing a new API version and retiring an old one without breaking existing consumers.
GraphQL Migration Readiness Checklist
Readiness items for migrating a REST API or adding a GraphQL layer without losing performance, security, or observability.
API Rate Limiting and Throttling Readiness Checklist
Verification items for designing fair, abuse-resistant rate limiting and throttling for a public or internal API.
Stacks20
Spring Boot Enterprise Stack
Java backend stack built on Spring Boot with PostgreSQL and Redis for production REST services and enterprise applications.
.NET Web API Stack
Modern C# backend stack using ASP.NET Core, Entity Framework Core, and SQL Server or PostgreSQL for high-performance cross-platform services.
FastAPI + SQLAlchemy Stack
Async Python backend stack using FastAPI, SQLAlchemy, and PostgreSQL for high-performance, type-hinted REST and ML-serving APIs.
Go + Gin + Postgres Stack
Lightweight Go REST backend using the Gin web framework with PostgreSQL and Redis for fast, simple, high-throughput HTTP APIs.
Node + Express + Mongo Stack
JavaScript backend stack using Node.js, Express, and MongoDB for flexible, schema-light REST APIs and rapid prototyping.
NestJS + Postgres Stack
Structured TypeScript backend stack using NestJS with PostgreSQL and an ORM for scalable, modular, enterprise-grade Node.js services.
Rails API Stack
Ruby on Rails backend in API mode with PostgreSQL and Redis for convention-driven, fast-to-build REST services and SaaS backends.
Ktor Kotlin Backend Stack
Asynchronous Kotlin backend using the Ktor framework with PostgreSQL and coroutines for lightweight, idiomatic, non-blocking services.
React + Spring Boot
A React frontend backed by a Java Spring Boot REST API, a workhorse enterprise stack for large, long-lived business applications.
React + Django REST Framework
A React frontend consuming a Django REST Framework API, a productive Python full-stack for data-rich and ML-adjacent web applications.
Express + React + Postgres
A classic JavaScript full stack: an Express REST API on Node.js, a React frontend, and a PostgreSQL database, flexible and widely understood.
Fastify + Prisma
A high-performance Node.js backend using Fastify with schema-based validation and Prisma ORM over PostgreSQL, built for low-overhead, type-safe APIs.
Vapor Swift Server
A server-side Swift web framework using async/await and a typed ORM, letting iOS-focused teams build backends in the same language as their apps.
Play Framework (Scala)
A reactive, stateless web framework on the JVM written for Scala (and Java), built on Akka for non-blocking, high-throughput web applications and APIs.
Ktor + Exposed
A lightweight, coroutine-based Kotlin web framework paired with the Exposed SQL library, for idiomatic, asynchronous Kotlin backends and APIs.
Rocket (Rust) Stack
An ergonomic, type-safe Rust web framework with compile-time route checking and request guards, paired with a database for fast, safe backends.
Symfony + API Platform
A robust PHP stack using the Symfony framework and API Platform to generate REST and GraphQL APIs from data models with documentation and standards built in.
ASP.NET MVC + EF Core
Microsoft's server-rendered web stack using ASP.NET Core MVC and Entity Framework Core over SQL Server or Postgres, for robust enterprise web applications.
Gin + GORM
A fast, lightweight Go web stack pairing the Gin HTTP framework with the GORM ORM, popular for high-performance REST APIs and backend services.
Echo + Ent
A performant Go web stack combining the Echo framework with Ent, an entity framework that generates type-safe, graph-aware data access code from schemas.
Comparisons4
REST in Go vs REST in Java
Building REST APIs in Go with its lean standard library versus in Java with mature frameworks like Spring Boot. Different trade-offs in speed, structure, and tooling.
REST vs GraphQL
REST exposes many resource-oriented endpoints; GraphQL exposes one typed endpoint where clients request exactly the fields they need.
gRPC vs REST
gRPC is a contract-first, binary, HTTP/2 RPC framework; REST is a resource-oriented, text-based HTTP style. Both build service APIs.
REST vs SOAP
SOAP is a rigid XML-based messaging protocol with built-in standards; REST is a lightweight resource-oriented HTTP style. Both expose web services.
FAQs2
What is the difference between REST and GraphQL?
REST exposes data through multiple fixed endpoints, each returning a predefined resource representation, and relies on HTTP verbs and status codes. Gr...
What are common API versioning strategies?
API versioning lets you evolve an interface without breaking existing clients. Common approaches are URI versioning (`/v1/orders`), which is explicit ...
Glossaries4
GraphQL
GraphQL is a query language and runtime for APIs that lets clients request exactly the fields they need from a single endpoint, returning a precisely shaped response.
OpenAPI
OpenAPI is a language-agnostic specification for describing HTTP APIs in a machine-readable document, enabling shared contracts, documentation, and code generation.
JSON
JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format that represents structured data as key-value objects and arrays.
CORS
CORS (Cross-Origin Resource Sharing) is a browser security mechanism that uses HTTP headers to let a server permit web pages from other origins to access its resources.