WordPress has evolved far beyond a traditional CMS. Modern WordPress development includes block-based architecture, reactive frontend components, structured data management, and AI integrations.
This cheat sheet covers 25 important WordPress APIs and technologies, explaining what they do and when developers might use them.
| API / Technology | What It Does |
|---|---|
| 1. Interactivity API | Provides a standardized way to build interactive frontend experiences in WordPress. It uses HTML directives and a reactive state management system to handle user interactions without requiring a separate React application. Useful for dropdown menus, accordions, live filtering, interactive search, and dynamic Gutenberg blocks. |
| 2. Block Bindings API | Connects Gutenberg block attributes to dynamic data sources, such as post metadata or custom registered sources. Instead of creating a separate custom block for every dynamic field, developers can bind supported attributes of existing blocks to external data. Particularly useful for displaying custom fields in block-based templates. |
| 3. Abilities API | Provides a standardized system for registering and executing capabilities within WordPress. Each ability defines its inputs, outputs, execution logic, and permission requirements. This makes WordPress functionality easier to discover and reuse across plugins, automation systems, REST integrations, and AI agents through compatible adapters. |
| 4. Block Hooks API | Allows plugins and themes to automatically insert blocks into block-based templates relative to other blocks. Developers can position blocks before, after, or inside supported target blocks without manually editing every template. Useful for adding promotional banners, notices, or plugin functionality to existing layouts. |
| 5. Block Context API | Enables parent blocks to provide contextual information to their nested blocks. For example, a Query Loop passes the current post ID to blocks inside its Post Template. Developers can use providesContext and usesContext to share information between blocks without manually configuring each child block. |
| 6. Block Supports API | Adds standardized editing capabilities to custom Gutenberg blocks. Through block.json, developers can enable features such as colors, typography, spacing, alignment, and borders. WordPress provides the corresponding editor controls and style handling, reducing the need to build custom settings interfaces. |
| 7. Script Modules API | Introduces native support for JavaScript ES Modules in WordPress. It allows developers to register and enqueue modules, declare dependencies, and use import maps. Particularly useful for modern frontend development and the Interactivity API, where modular JavaScript is preferred over traditional globally loaded scripts. |
| 8. DataViews | Provides reusable React components for displaying and managing collections of data in the WordPress admin interface. Supports layouts such as tables and grids, along with filtering, sorting, pagination, and actions. Useful for building modern management interfaces for custom post types, products, or plugin-specific records. |
| 9. DataForm | Provides a standardized way to build data-editing forms using field definitions. Developers describe fields and their presentation, while DataForm handles much of the form interface. Useful for editing structured records, plugin settings, and custom administrative interfaces without manually implementing every input component. |
| 10. Fields API | Supports standardized field definitions and field-type extensibility within modern WordPress data interfaces. It helps developers describe data fields consistently and integrate them with components such as DataForm. It is not a complete replacement for ACF, which provides a broader custom-field management system. |
| 11. Block Variations API | Allows developers to create predefined configurations of existing Gutenberg blocks. A variation can define attributes, inner blocks, and editor behavior while reusing the original block implementation. For example, developers can create specialized Query Loop variations for portfolios, testimonials, or products without building entirely new blocks. |
| 12. Block Patterns API | Enables registration of reusable layouts composed of multiple Gutenberg blocks. Patterns can represent hero sections, pricing tables, testimonials, or complete page sections. WordPress also supports synced patterns and pattern overrides, allowing developers to maintain consistent layouts while controlling which content can vary between instances. |
| 13. Pattern Overrides | Allows selected content within a synced pattern to be customized independently for each instance while preserving the shared layout and design. For example, multiple cards can use the same synchronized structure but display different headings and images. Particularly useful for maintaining design consistency across large websites. |
| 14. HTML API | Provides tools for parsing and modifying HTML more reliably than regular expressions. WP_HTML_Tag_Processor can inspect and modify HTML tag attributes, while WP_HTML_Processor understands supported HTML document structures. Useful for safely adding classes, modifying attributes, and processing HTML generated by blocks or plugins. |
| 15. Command Palette API | Allows developers to register custom commands in supported WordPress editor interfaces. Commands can open pages, trigger actions, or navigate to specific features. Useful for improving administrative workflows and providing quick access to frequently used plugin functionality. |
| 16. Preferences API | Provides a system for managing user interface preferences in WordPress applications. Developers can store and retrieve settings such as interface modes, panel visibility, and other editor preferences. Unlike the Options API, it focuses on preferences associated with the user experience rather than general site configuration. |
| 17. WP AI Client | Provides a standardized PHP interface for integrating AI capabilities into WordPress. It helps developers work with supported AI providers through a common abstraction instead of writing separate implementations for each provider. Potential use cases include content generation, translation, image descriptions, summarization, and AI-powered plugin features. |
| 18. Connectors API | Provides infrastructure for registering and managing connections to supported external services, including AI providers. It helps separate connection configuration and credential management from the functionality that uses those services. Useful for plugins that need access to external APIs without implementing their own complete connection-management interfaces. |
| 19. PHP-only Block Registration | Allows developers to register certain server-rendered Gutenberg blocks primarily through PHP and block metadata, without writing a custom React editing component. WordPress can provide editing controls for supported block attributes. Useful for simpler dynamic blocks, although complex editor experiences may still require custom JavaScript. |
| 20. REST API | Exposes WordPress resources and functionality through HTTP endpoints using JSON. Developers can retrieve, create, update, and delete posts, users, taxonomies, and other supported resources. Custom endpoints can also be registered. Essential for headless WordPress, mobile applications, JavaScript frontends, external integrations, and automation. |
| 21. Settings API | Provides a structured way to register settings, sections, and fields for WordPress administration pages. It integrates with WordPress's settings management and supports validation and sanitization callbacks. Useful for building secure and maintainable configuration interfaces for themes and plugins. |
| 22. Transients API | Provides a simple mechanism for temporarily caching data with an expiration time. Developers can cache expensive database queries, external API responses, or calculated results to improve performance. Transients may be stored in the database or an external object cache, and they can disappear before their expiration time. |
| 23. Options API | Provides functions for storing and retrieving site-level configuration values in the WordPress database. Commonly used for plugin settings, feature flags, and application configuration. Supports functions such as get_option(), add_option(), and update_option(). Developers should also consider autoloading behavior when storing large amounts of data. |
| 24. WP-Cron API | Provides a scheduling mechanism for executing WordPress tasks at specific times or recurring intervals. Common use cases include scheduled publishing, cleanup operations, synchronization, and background maintenance. Unlike a traditional system cron, WP-Cron is normally triggered by site requests, so execution timing is not guaranteed without additional server configuration. |
| 25. Heartbeat API | Enables periodic communication between the WordPress browser interface and the server using AJAX requests. It supports features such as post locking, session monitoring, and editor-related updates. Developers can extend it for custom real-time-like administrative functionality, although excessive polling can increase server load. |
Understanding the Bigger Picture
These technologies can be grouped into several areas of modern WordPress development.
Block development and Full Site Editing: Block Bindings, Block Hooks, Block Context, Block Supports, Block Variations, Block Patterns, and Pattern Overrides help developers build reusable, configurable, and maintainable block-based websites.
Frontend development: The Interactivity API, Script Modules API, and HTML API provide modern approaches to interactive components, JavaScript architecture, and HTML processing.
Admin interfaces: DataViews, DataForm, Fields API, Command Palette API, and Preferences API help developers create more consistent WordPress administration experiences.
AI and automation: The Abilities API, WP AI Client, and Connectors API provide building blocks for standardized operations, AI integrations, and external service connections.
Core WordPress development: REST API, Settings API, Transients API, Options API, WP-Cron API, and Heartbeat API remain essential for developing reliable plugins, integrations, and custom WordPress applications.
Final Thoughts
In my opinion, it's really cool how WordPress is evolving and changing, especially compared to many CMSs that are slowly but surely dying out.