WP API

The WordPress REST API is a web interface and JSON-based content API that allows for the retrieval and modification of site content, users, and metadata using standard HTTP methods. It functions as a headless CMS interface, decoupling content management from the frontend by exposing site data through a programmable RESTful controller.

The system is distinguished by its hypermedia-driven discovery and JSON-schema-based validation, which allow clients to programmatically locate resources and ensure predictable data exchange. It utilizes namespace-based endpoint registration to organize routes and supports a flexible authentication layer including application passwords, session cookies, and third-party identity standards.

The API covers a broad range of resource management capabilities, including the handling of posts, pages, media, and block-based content. It provides comprehensive utilities for response management, such as resource embedding, pagination, and field filtering, alongside tools for managing content revisions and site administration.

Support is provided for language-specific SDKs to abstract network requests into high-level programmatic interfaces.

Features

Headless CMS - Provides a headless CMS interface that decouples content management from the frontend via a programmable API.
API Resource Management - Implements standardized CRUD operations for managing the lifecycle of site data entities via JSON.
REST API Content Exposure - Maps URIs and methods to endpoints that expose site content and metadata as JSON for decoupled applications.
REST API Implementations - Allows for the definition of unique endpoints and data schemas to expose custom business logic via a RESTful interface.
Custom Content Type Definitions - Allows the definition of custom content types and taxonomies that are exposed as programmable API resources.
Headless CMS Integrations - Enables a decoupled workflow by bridging the CMS backend to external frontends via API resources and data embedding.
Headless WordPress Development - Provides a headless architecture where WordPress acts as a backend API for decoupled frontend applications.
Page Content Retrievals - Provides programmatic fetching of specific site pages using unique identifiers and query filtering.
Site Content Management - Provides JSON-based retrieval and updating of posts, pages, categories, tags, and media.
WordPress REST APIs - Acts as the primary web interface for interacting with WordPress content and settings using standard HTTP methods.
Data Resource Management - Implements standard CRUD operations for managing site resources through model synchronization.
WordPress Post Fetchers - Provides comprehensive endpoints for fetching post collections or individual records using filtered queries.
Server-Side RESTful Controllers - Provides a framework for defining custom resource controllers and endpoints to manage site data.
Application Passwords - Provides a system for creating, retrieving, and deleting unique application passwords for external service access.
API Request Authentication - Implements a security layer that validates API requests using a variety of authentication methods including cookies and passwords.
Basic Authentication - Validates requests from external scripts using unique, user-generated passwords via standard HTTP Basic Authentication.
Session Cookie Authentications - Uses browser cookies and unique tokens to verify user identity and prevent cross-site request forgery.
Hybrid Token-Cookie Authentications - Verifies identity through a combination of session cookies and application-specific passwords for secure remote API access.
Web Request Authorizations - Verifies that incoming HTTP requests meet required privilege levels before allowing data modification.
Data Schema Definitions - Defines the structure of input parameters and output properties to ensure predictable data exchange.
JSON Schema Validation - Uses predefined JSON schemas to automatically validate, sanitize, and type-check incoming request parameters.
Object Schema Definitions - Describes the structure of API objects using JSON Schema for client-side discovery and validation.
Request Validation - Defines required fields, default values, and sanitization callbacks for incoming request data.
User Detail Retrievers - Fetches individual user records or filtered collections to return membership and identity details.
API Endpoint Definitions - Provides the ability to define unique routes and callback functions to handle custom API requests.
API Request Handling - Implements logic for intercepting and processing incoming network requests to dispatch them to the correct API endpoint callbacks.
Class-Based Resource Mapping - Organizes CRUD logic into standardized classes that map HTTP methods to specific data model operations.
Response Schema Definitions - Specifies data format, field types, and descriptions for responses to ensure clients understand the structure.
Custom API Endpoints - Enables the registration of unique URLs to custom logic for exposing data through a standardized REST interface.
JSON APIs - Implements a JSON API for retrieving and modifying site content, users, and metadata.
Request Schema Validators - Uses JSON Schema to automatically check and sanitize incoming request parameters for security.
Resource Schema Definitions - Specifies expected data types and arguments for resources to ensure consistent request validation.
Template Part Management - Allows retrieving, creating, or deleting template part records to synchronize layout components.
Media Resource Retrievals - Fetches collections of media records and metadata using query parameters for filtered retrieval.
Site Content Search - Retrieves collections of matching results across the site based on search queries and filters.
Template Retrievals - Fetches lists of all site templates or specific template records using unique identifiers.
Collection Pagination - Retrieves large data collections in smaller chunks using page numbers or offsets.
Permission Callbacks - Checks user permissions via internal callbacks before executing endpoints to ensure data privacy.
Resource Collection Querying - Allows retrieval of resource lists with support for custom ordering, filtering, and automatic pagination.
Result Sorting - Organizes returned data in ascending or descending order based on specific resource fields.
Server Capability Discovery - Exposes self-documentation and endpoint details via an index endpoint for machine-discovery of API capabilities.
API Root Discovery - Enables clients to locate the API entry point using link headers or HTML elements for automated integration.
Regex-Based Route Matching - Uses regular expressions in request paths to capture variables and route them to specific endpoint handlers.
Administrative Site Settings - Exposes site-wide configuration and global settings through a programmatic JSON response.
Programmatic Site Administration - Allows remote management of site settings, plugins, themes, and user accounts through a programmatic interface.
Authentication Discovery - Allows clients to programmatically query the root directory for supported authentication methods and configurations.
Third-Party Identity Integrations - Integrates third-party identity standards such as OAuth and tokens to verify remote applications.
API Response Filtering - Accepts query or body parameters through validation callbacks to modify data returned by an endpoint.
Hypermedia Link Generation - Provides automated creation of navigational links within API responses to facilitate resource discovery.
Hypermedia Resource Discovery - Adds hypermedia discovery links to responses to help clients find related resources via query variables.
Field Filtering - Restricts returned data to a specific subset of properties to reduce payload size.
Endpoint Namespace Grouping - Implements namespace-based endpoint registration to prevent routing collisions between core and third-party extensions.
Response Lifecycle Hooks - Processes incoming headers and parameters via lifecycle hooks to generate structured response objects with custom status codes.
Content Block HTML Rendering - Converts block markup into final HTML using a server-side rendering engine.
Controller Patterns - Organizes complex API logic into standardized controller classes to manage resource lifecycles.
Endpoint Discovery - Allows clients to query the system to identify supported resources and their specific API locations.
CRUD API Implementations - Implements consistent CRUD patterns and response shaping through inheritance from base resource controllers.
Dynamic API Routing - Uses regular expression path variables to capture URL inputs, allowing a single endpoint to handle multiple resources.
Response Field Mappings - Injects custom data fields into response objects to provide additional context to the client.
Custom Response Fields - Injects arbitrary data or whitelist metadata into responses using custom callbacks or schema definitions.
Post Type Definition Retrievals - Fetches records of available content types including schemas, labels, and associated taxonomies.
Referenced Resource Embedding - Includes full data of related resources within a single API response to reduce total request volume.
Response Mutation Callbacks - Uses registered hooks and callbacks to inject custom fields or modify outgoing data.

apostrophecms/apostrophe

4,524View on GitHub

Apostrophe is an open-source Node.js headless content management system that delivers structured content through REST APIs while providing a visual in-context page editor for live editing. It is built on a module-based plugin architecture that extends CMS functionality through reusable modules, each encapsulating logic, configuration, and templates. The system uses schema-driven content modeling to define data structures and validation rules through configurable schemas and custom field types, with all content stored as flexible JSON-like documents in MongoDB. The platform distinguishes itsel

marmelab/react-admin

26,780View on GitHub

React-admin is a framework for building data-driven administrative interfaces that connect to REST or GraphQL backends. It provides a comprehensive suite of tools for managing the full lifecycle of administrative applications, including resource-oriented routing, declarative form scaffolding, and context-driven state management. By utilizing a modular adapter-based architecture, the framework abstracts backend communication, allowing developers to build consistent CRUD interfaces that handle data fetching, authentication, and synchronization automatically. The project distinguishes itself thr

ponzu-cms/ponzu

5,757View on GitHub

Ponzu is a content management framework written in Go that functions as a headless CMS with a built-in JSON API and an automatically generated admin dashboard. It is designed to be compiled into a single binary, serving both the content API and the administrative interface from a single HTTP server. The framework distinguishes itself through automatic HTTPS certificate management via Let's Encrypt, enabling secure HTTP/2 delivery out of the box. It provides compile-time content scaffolding, allowing developers to define custom content types from the command line and generate the corresponding

aws-powertools/powertools-lambda-python

3,267View on GitHub

AWS Powertools for Python is a utility framework designed for building production-ready Python functions on AWS Lambda. It provides a comprehensive suite of tools for observability, event parsing, routing, and idempotency management to streamline the development of serverless applications. The project distinguishes itself through specialized capabilities for event-driven architectures and AI agent orchestration. It enables the implementation of AI agents by exposing functions as tools via OpenAPI schemas and managing conversation states. Additionally, it features an idempotency library that p

WP-APIWP-APIArchived

Features