La API Block Bindings es una potente herramienta del editor de bloques que te permite conectar cualquier fuente de datos a los atributos de un bloque.
Esta API se introdujo por primera vez en WordPress 6.5 y, en su implementación inicial, permitía a los usuarios de WordPress mostrar valores de campos personalizados dentro de entradas y páginas.
La API Block Bindings sirve de base para otras potentes funcionalidades de WordPress. Algunos ejemplos incluyen los Synced pattern overrides (anulaciones en patrones sincronizados) y la variación del bloque «Post Date» introducida en WordPress 6.9.
Entonces, ¿qué es exactamente la API Block Bindings? ¿Y para qué se utiliza? Te ofreceremos una introducción sencilla y un ejemplo real que muestra cómo crear enlaces entre los bloques de Gutenberg y fuentes de datos externas.
Manos a la obra.
La API Block Bindings: Conceptos básicos
Como ya hemos mencionado anteriormente, la API Block Bindings te permite crear vínculos entre una fuente de datos y los atributos de un bloque.
Si no estás familiarizado con los atributos de bloque, navega hasta el directorio src de la biblioteca de bloques del proyecto Gutenberg en GitHub, busca el bloque Paragraph (Párrafo) y abre el archivo block.json. La propiedad attributes proporciona una lista de los atributos del bloque Párrafo.
"attributes": {
"content": {
"type": "rich-text",
"source": "rich-text",
"selector": "p",
"role": "content"
},
"dropCap": {
"type": "boolean",
"default": false
},
"placeholder": {
"type": "string"
},
"direction": {
"type": "string",
"enum": [ "ltr", "rtl" ]
}
},Los siguientes bloques son soportados por la API Block Bindings a partir de WordPress 6.9 y, por lo tanto, pueden vincularse a tus campos personalizados:
| Bloques compatibles | Atributos |
|---|---|
| Paragraph (Párrafo) | content |
| Heading (Encabezado) | content |
| Image (Imagen) | id, url, alt, title, caption |
| Button (Botón) | text, url, linkTarget, rel |
Para conectar tus campos personalizados a los bloques de Gutenberg, primero debes registrarlos. El siguiente código registra un campo personalizado a través de un plugin de WordPress o del archivofunctions.php de tu tema:
add_action( 'init', function() {
register_post_meta( 'your-post-type', 'myplugin_meta_key', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'City name', 'textdomain' ),
'auth_callback' => 'is_user_logged_in',
] );
} );register_post_meta acepta una array de atributos que definen las características de los campos personalizados, y la documentación proporciona una lista completa de ellos. Para que un campo personalizado esté disponible para la API Block Bindings, debes establecer show_in_rest en true. Desde WordPress 6.9, string es el único tipo soportado.
Para ver la API Block Bindings en acción con campos personalizados, crea un nuevo plugin de WordPress y registra un campo meta con el código mostrado arriba.
<?php
/**
* Plugin Name: Block Bindings example
* Description: Example plugin that uses the Block Bindings API.
* Version: 1.0.0
* Author: Your Name
* License: GPL2 or later
* Text Domain: block-bindings-example
*/
if ( ! defined( 'ABSPATH' ) ) {
exit;
}
add_action( 'init', function() {
register_post_meta( '', 'block_bindings_image_url', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'City name', 'block-bindings-example' ),
'auth_callback' => 'is_user_logged_in',
] );
} );En tu panel de control de WordPress, activa el plugin. A continuación, ve a la pantalla Entradas y crea una nueva entrada. Cuando selecciones un bloque soportado, el panel Atributos de la barra lateral Configuración del bloque mostrará la lista de atributos que se pueden vincular a un campo personalizado registrado.
Abre el menú Opciones en la esquina superior derecha y selecciona Preferencias. En la pestaña General, localiza la sección Avanzado y activa los campos personalizados. Guarda los cambios, espera a que se recargue la página y vuelve al editor.
Tu siguiente paso es insertar un bloque Imagen. Con el bloque seleccionado, haz clic en el icono + del panel Atributos y selecciona el atributo url. El panel Atributos mostrará entonces una lista de metacampos disponibles. Vuelve a seleccionar url. Ahora verás la lista de meta campos disponibles para el tipo de entrada actual.
Selecciona tu meta campo y guarda la entrada. Ahora deberías ver tu imagen tanto en el editor como en el frontend.
Desde la versión 6.7 de WordPress, puedes utilizar el atributo Label para mostrar texto en la interfaz del editor. El siguiente bloque de código muestra un ejemplo:
add_action( 'init', function() {
register_post_meta( '', 'block_bindings_image_url', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'City image', 'block-bindings-example' ),
'label' => __('Image URL'),
'auth_callback' => 'is_user_logged_in',
] );
} );
Al abrir el editor de código, puedes ver un objeto JSON dentro del delimitador del bloque de imagen. La propiedad metadata.bindings.url muestra que el url del bloque de imagen está vinculado a un campo de metadatos.
<!-- wp:image {
"metadata":{
"bindings":{
"url":{
"source":"core/post-meta",
"args":{
"key":"block_bindings_image_url"
}
}
}
}
} -->
<figure class="wp-block-image"><img alt="/></figure>
<!-- /wp:image -->La propiedad source especifica la fuente de datos para los block bindings. Por su parte, la propiedad args.key establece una referencia a tu campo de metadatos (meta field).
El aspecto más interesante de la API Block Bindings es su capacidad para registrar fuentes de datos personalizadas, lo que abre nuevas e interesantes posibilidades a los desarrolladores. A continuación, exploraremos cómo utilizar datos de servicios de terceros con la API Block Bindings.
Cómo registrar fuentes de datos personalizadas de Block Bindings: Un ejemplo real
Una vez que te hayas familiarizado con los conceptos básicos de la API Block Bindings, podremos pasar a sus aspectos más avanzados e interesantes para los desarrolladores.
Como se mencionó anteriormente, la API Block Bindings te permite registrar fuentes de datos personalizadas. Esto te permite recuperar datos de una fuente remota y/o manipular datos sin procesar para generar información útil que se puede insertar automáticamente en tu contenido.
En esta sección, aprenderás a maximizar el potencial de Block Bindings mediante un ejemplo práctico que podrás utilizar como base para desarrollar tus propias aplicaciones personalizadas.
Supongamos que deseas recuperar datos de una fuente externa y mostrarlos en tus entradas, páginas o tipos de entradas personalizadas. Por ejemplo, puedes consultar una API de servicio meteorológico enviando una solicitud con la latitud y la longitud de una ciudad para obtener datos meteorológicos en tiempo real, que luego podrías mostrar en tu sitio.
Gracias a la API de Block Bindings, puedes mostrar la temperatura actual o proporcionar a tus lectores la previsión meteorológica para los próximos días. También puedes cambiar mediante programación el atributo url de una o varias imágenes de la página en función de las condiciones meteorológicas.
Para añadir esta funcionalidad a tu sitio web de WordPress, debes crear un plugin. Sigue estos pasos:
Paso 1: Crear un plugin básico
El primer paso es crear los archivos del plugin. Ve al directorio wp-content/plugins de tu instalación de WordPress y crea una nueva carpeta llamada block-bindings-example. Dentro de esta carpeta, añade los siguientes archivos:
/wp-content/plugins/
└── /block-bindings-example/
├── block-bindings-example.php
└── /includes/
├── binding-sources.php
├── meta-fields.php
└── weather-api.phpAbre el archivo block-bindings-example.php en tu editor de código favorito y añade el siguiente código:
<?php
/**
* Plugin Name: Block Bindings Example
* Description: Use WordPress Block Bindings API (6.5+) to dynamically bind weather data from Open-Meteo API to Gutenberg blocks using custom post meta and a custom binding source.
* Version: 1.0.0
* Author: Your Name
* License: GPL2 or later
* Text Domain: block-bindings-example
*/
if ( ! defined( 'ABSPATH' ) ) {
exit; // Exit if accessed directly
}
/**
* Cache duration for weather data: 30 minutes
* This reduces API calls and improves performance
*/
define( 'BB_WEATHER_CACHE_TIME', HOUR_IN_SECONDS / 2 );
require_once plugin_dir_path( __FILE__ ) . 'includes/meta-fields.php';
require_once plugin_dir_path( __FILE__ ) . 'includes/binding-sources.php';
require_once plugin_dir_path( __FILE__ ) . 'includes/weather-api.php';
/**
* Setup function
*/
function bb_init_setup() {
bb_register_post_meta();
bb_register_binding_sources();
}
add_action( 'init', 'bb_init_setup' );Esto es lo que hace este código
- La constante
BB_WEATHER_CACHE_TIMEdetermina cuánto tiempo se almacenan en caché los datos meteorológicos. Esto reduce las llamadas a la API, mejora el rendimiento de la página y reduce los costes del servicio. - Las expresiones
require_onceincluyen los scripts necesarios para registrar los metacampos, registrar la fuente de enlace y recuperar datos de la API. - La función de configuración llama a dos funciones que registran los campos meta de la publicación y las fuentes de enlace personalizadas.
Paso 2: Registrar los campos meta (post meta fields)
El siguiente paso es registrar los metacampos que necesitas para tu caso de uso. Abre el archivo meta-fields.php en la carpeta includes y añade el siguiente código:
<?php
/**
* Registers custom post meta fields so they appear in the REST API and Block Bindings editor panel
*/
function bb_register_post_meta() {
if ( ! function_exists( 'register_post_meta' ) ) {
return;
}
register_post_meta( 'post', 'block_bindings_city_name', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'Add city name', 'block-bindings-example' ),
'label' => __( 'City name', 'block-bindings-example' ),
'auth_callback' => 'is_user_logged_in',
] );
register_post_meta( 'post', 'block_bindings_image_url', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'Add city image URL', 'block-bindings-example' ),
'label' => __( 'City image URL', 'block-bindings-example' ),
'auth_callback' => 'is_user_logged_in',
] );
register_post_meta( 'post', 'block_bindings_city_lat', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'Add city latitude', 'block-bindings-example' ),
'label' => __( 'Latitude', 'block-bindings-example' ),
'auth_callback' => 'is_user_logged_in',
] );
register_post_meta( 'post', 'block_bindings_city_lng', [
'show_in_rest' => true,
'single' => true,
'type' => 'string',
'description' => __( 'Add city longitude', 'block-bindings-example' ),
'label' => __( 'Longitude', 'block-bindings-example' ),
'auth_callback' => 'is_user_logged_in',
] );
}La función register_post_meta registra una clave de metadatos (meta key) para su uso en las entradas. Ten en cuenta que para utilizar los metacampos registrados de esta forma con la API Block Bindings, debes establecer show_in_rest en true y type en string. Consulta la documentación para obtener más información.
Paso 3: Registrar la fuente Block Bindings
Es hora de registrar tu fuente de enlaces. Abre el archivo binding-sources.php y añade el siguiente código:
<?php
/**
* Registers a custom Block Bindings source: bb/weather-condition
*/
function bb_register_binding_sources() {
if ( ! function_exists( 'register_block_bindings_source' ) ) {
return;
}
register_block_bindings_source(
'bb/weather-condition',
[
'label' => __( 'Weather Condition', 'block-bindings-example' ),
'get_value_callback' => 'bb_get_weather_condition_value',
'uses_context' => [ 'postId' ], // We need postId to get meta values
]
);
}La función register_block_bindings_source() requiere el nombre de la fuente y una función de retorno (callback) que recupere los datos de una fuente y devuelva el valor procesado.
A continuación, define la función de retorno en ese mismo archivo binding-sources.php.
function bb_get_weather_condition_value( array $source_args, WP_Block $block_instance ) {
$key = $source_args['key'] ?? null;
if ( ! $key ) {
return null;
}
// Get current post ID from block context (always available in post content)
$post_id = $block_instance->context['postId'] ?? null;
// Fallback: use global loop if context is missing
if ( ! $post_id && in_the_loop() ) {
$post_id = get_the_ID();
}
if ( ! $post_id || $post_id <= 0 ) {
error_log( 'BB DEBUG: Could not determine post ID for weather binding' );
return null;
}
$weather_data = bb_fetch_and_cache_weather_data( $post_id );
if ( ! is_array( $weather_data ) || ! isset( $weather_data[ $key ] ) ) {
return null;
}
$value = $weather_data[ $key ];
// Append °C symbol for temperature
if ( $key === 'temperature' ) {
return $value . '°C';
}
return $value;
}Vamos a desglosar esta función:
$source_args['key']identifica los datos vinculados al atributo del bloque.- La siguiente línea recupera el ID de la entrada actual de
context. Si faltacontext, como puede ocurrir con las vistas previas, el ID de la entrada actual se recupera conget_the_ID(). - A continuación, llama a la función
bb_fetch_and_cache_weather_data, que recupera los datos de la API. Definiremos esta función en el siguiente paso. $weather_data[$key]contiene los datos proporcionados por la API, como la temperatura y el estado del tiempo.- Si la clave es
temperature, añade°Cal valor proporcionado. - A continuación, la función devuelve el valor final.
Paso 4: Recuperar datos de una fuente externa
Como ya hemos dicho, recuperamos datos del servicio Open-Meteo (gratuito para uso no comercial).
Para recuperar la temperatura actual y las condiciones meteorológicas, tienes que enviar una solicitud a la API que incluya la latitud y la longitud de una ubicación determinada, además de la variable de consulta (query var) current=weather_code,temperature_2m. A continuación se muestra un ejemplo de solicitud:
https://api.open-meteo.com/v1/forecast?latitude=-33.8717&longitude=151.2299¤t=weather_code,temperature_2mLa API proporciona una respuesta similar a la siguiente:
{
"latitude": -33.8717,
"longitude": 151.2299,
"generationtime_ms": 0.030875205993652344,
"utc_offset_seconds": 0,
"timezone": "GMT",
"timezone_abbreviation": "GMT",
"elevation": 13.0,
"current_units": {
"time": "iso8601",
"interval": "seconds",
"weather_code": "wmo code",
"temperature_2m":"°C"
},
"current": {
"time": "2025-12-01T16:00",
"interval": 900,
"weather_code": 3,
"temperature_2m":7.3
}
}
Ahora que ya sabes cómo obtener los datos que necesitas, abre el archivo weather-api.php y añade el siguiente código:
function bb_fetch_and_cache_weather_data( $post_id ) {
$lat = get_post_meta( $post_id, 'block_bindings_city_lat', true );
$lng = get_post_meta( $post_id, 'block_bindings_city_lng', true );
$lat = str_replace( ',', '.', trim( $lat ) );
$lng = str_replace( ',', '.', trim( $lng ) );
if ( ! is_numeric( $lat ) || ! is_numeric( $lng ) ) {
error_log( 'BB DEBUG: Invalid latitude/longitude values after normalization' );
return false;
}
$transient_key = 'bb_weather_data_' . $post_id;
$cached_data = get_transient( $transient_key );
if ( $cached_data !== false ) {
error_log( "BB DEBUG: Cache hit for post ID {$post_id}" );
return $cached_data;
}
// Build Open-Meteo API URL
$api_url = sprintf(
'https://api.open-meteo.com/v1/forecast?latitude=%s&longitude=%s¤t=weather_code,temperature_2m',
rawurlencode( $lat ),
rawurlencode( $lng )
);
error_log( "BB DEBUG: Fetching weather data from: {$api_url}" );
$response = wp_remote_get( $api_url, [ 'timeout' => 10 ] );
if ( is_wp_error( $response ) ) {
error_log( 'BB DEBUG: API request failed – ' . $response->get_error_message() );
return false;
}
if ( wp_remote_retrieve_response_code( $response ) !== 200 ) {
error_log( 'BB DEBUG: API returned non-200 status code' );
return false;
}
$body = wp_remote_retrieve_body( $response );
$data = json_decode( $body, true );
if ( ! $data || ! isset( $data['current'] ) ) {
error_log( 'BB DEBUG: Invalid or empty API response' );
return false;
}
$temperature = $data['current']['temperature_2m'] ?? null;
$weather_code = $data['current']['weather_code'] ?? 0;
$mapped_data = [
'temperature' => round( (float) $temperature ),
'weather_state' => bb_map_wmo_code_to_state( (int) $weather_code ),
];
// Cache for 30 minutes
set_transient( $transient_key, $mapped_data, BB_WEATHER_CACHE_TIME );
error_log( 'BB DEBUG: Weather data fetched and cached successfully' );
return $mapped_data;
}Esta función recupera los datos meteorológicos actuales de la API Open-Meteo y los almacena en caché utilizando transients. Vamos a verlo más detalladamente.
- Dos llamadas a
get_post_metarecuperan la latitud y la longitud de tu ubicación. - Las dos líneas siguientes normalizan el separador decimal en caso de que el usuario introduzca una coma en lugar de un punto.
- El bloque condicional comprueba si los valores están en formato numérico utilizando
is_numeric(). - A continuación, comprueba si los datos están en caché. Si es así, devuelve los datos almacenados en caché y detiene la función sin enviar ninguna petición a la API.
- Si no se encuentran datos en la caché, construye la petición y almacena la respuesta.
- Las siguientes líneas proporcionan
temperatureyweather_code. weather_codese asigna aweather_stategracias a la funciónbb_map_wmo_code_to_state, que se define a continuación.- Los datos se guardan con
set_transient. - Por último, la función devuelve los datos mapeados.
Por último, define la función que traduce weather_code a una cadena legible por humanos:
function bb_map_wmo_code_to_state( $code ) {
if ( $code >= 0 && $code <= 3 ) {
return 'clear';
} elseif ( $code >= 51 && $code <= 67 ) {
return 'rainy';
} elseif ( $code >= 71 && $code <= 77 ) {
return 'snowy';
} elseif ( $code >= 95 ) {
return 'thunderstorm';
}
return 'cloudy';
}El código está completo, y tu plugin está listo para ser probado.
Cómo utilizar la API Block Bindings
¡Es hora de aprender a utilizar las nuevas funcionalidades añadidas a tu sitio con la API Block Bindings!
En tu panel de control de WordPress, ve a la pantalla Plugins y activa el plugin Block Bindings Example que acabas de crear.
Después, crea una nueva entrada o página. Añade un bloque Imagen, un título y cuatro bloques Fila (Row) que contengan dos párrafos cada uno, como se muestra en la imagen siguiente. A continuación, guarda la entrada.
A continuación, añade tus campos personalizados y vuelve a guardar la entrada.
Selecciona el bloque Imagen y busca el panel Atributos en la barra lateral Configuración del bloque. Haz clic en el botón + para abrir el menú desplegable, que muestra la lista de atributos del bloque Imagen que admiten Block Bindings. Selecciona el elemento url.
Tras seleccionar el atributo de bloque, la pestaña Avanzado mostrará un nuevo elemento url con la descripción «No conectado» Vuelve a hacer clic en el elemento url para ver la lista de fuentes de vinculación disponibles. Post Meta proporciona los cuatro campos personalizados registrados para el tipo de entrada, junto con sus respectivos valores. Selecciona URL de imagen de la ciudad.
Has asignado el metacampo URL de la imagen de la ciudad al atributo url del bloque Imagen. Ahora deberías ver una foto de la ciudad que has elegido.
Sigue el mismo proceso para los demás meta campos. Asigna el campo Nombre de la ciudad al atributo content del bloque Encabezado y los campos Latitude y Longitude a los bloques Párrafo correspondientes.
Ahora, conecta los dos últimos bloques a tu fuente de binding personalizada. Lamentablemente, como has visto en las capturas de pantalla anteriores, esta opción no está disponible en la interfaz de usuario del editor.
Actualmente, tienes que cambiar al editor de código y escribir manualmente el marcado (markup) para los dos bloques vinculados a tu fuente de binding. A continuación, tienes el código para mostrar la temperatura proporcionada por el servicio de Open-Meteo:
<!-- wp:paragraph {
"metadata":{
"bindings":{
"content":{
"source":"bb/weather-condition",
"args":{
"key":"temperature"
}
}
}
}
} -->
<p>Placeholder</p>
<!-- /wp:paragraph -->Con este método, el nombre de tu fuente de datos aparecerá en el editor como Weather Condition (Condición meteorológica), pero los datos reales sólo serán visibles en el front-end.
Está claro que añadir manualmente un objeto JSON al marcado del bloque no es un proceso sencillo para el usuario. Afortunadamente, WordPress 6.9 introdujo mejoras significativas en la API de Block Bindings, lo que permite crear una interfaz de usuario para fuentes de datos personalizadas. Intentemos mejorar nuestro plugin con una interfaz de usuario personalizada.
Cómo crear una IU para tus fuentes personalizadas de Block Bindings
Para crear una interfaz de usuario para tu fuente de binding personalizada, necesitas escribir algo de código JavaScript. En primer lugar, crea una subcarpeta js en /includes y, a continuación, crea un archivo block-bindings-ui.js dentro de ella. La estructura del plugin quedaría así:
/wp-content/plugins/
└── /block-bindings-example/
├── block-bindings-example.php
└── /includes/
├── binding-sources.php
├── meta-fields.php
└── weather-api.php
└── /js/
└── block-bindings-ui.jsComo primer paso, añade el script JS al archivo principal de tu plugin:
function bb_enqueue_weather_bindings_ui() {
if ( ! function_exists( 'register_block_bindings_source' ) ) {
return;
}
$js_file_path = plugin_dir_path( __FILE__ ) . 'includes/js/block-bindings-ui.js';
if ( ! file_exists( $js_file_path ) ) {
return;
}
// Enqueue the script only in the editor
wp_enqueue_script(
'bb-weather-bindings-ui',
plugin_dir_url( __FILE__ ) . 'includes/js/block-bindings-ui.js',
[ 'wp-blocks', 'wp-element', 'wp-dom-ready', 'wp-block-bindings' ],
filemtime( $js_file_path ),
true
);
}
add_action( 'enqueue_block_editor_assets', 'bb_enqueue_weather_bindings_ui' );Esto es lo que hace esta función
- En primer lugar, comprueba que existe la función
register_block_bindings_source(). - A continuación, comprueba que el archivo
block-bindings-ui.jsexiste en la carpeta/includes/jsdel plugin. - La función
wp_enqueue_script()pone en cola el script para su uso en el editor. Para una descripción detallada de la función, consulta la documentación. - Utiliza el hook
enqueue_block_editor_assetspara poner en cola los scripts para la interfaz de edición.
Ahora abre el archivo block-bindings-ui.js y escribe el siguiente código:
wp.blocks.registerBlockBindingsSource({
name: 'bb/weather-condition',
label: 'Weather Condition',
useContext: [ 'postId', 'postType' ],
getValues: ( { bindings } ) => {
if ( bindings.content?.args?.key === 'temperature' ) {
return {
content: 'Current temperature provided by Open-Meteo.',
};
}
if ( bindings.content?.args?.key === 'weather_state' ) {
return {
content: 'Current conditions.',
};
}
return {
content: bindings.content,
};
},
getFieldsList() {
return [
{ label: 'Temperature (°C)', type: 'string', args: { key: 'temperature' } },
{ label: 'Weather Conditions', type: 'string', args: { key: 'weather_state' } }
];
}
});- La función
registerBlockBindingsSource()registra una fuente de enlace en el editor de bloques. namees un identificador único para tu fuente de binding. Debe coincidir exactamente con el nombre utilizado en PHP conregister_block_bindings_source().labeles un nombre legible por humanos que aparece en el desplegable Fuente del panel Atributos.useContextestablece los valores de contexto que esta fuente necesita del bloque.postIdes necesario para que la fuente sepa qué meta/datos meteorológicos de la entrada debe leer.getValuesproporciona una vista previa del valor delimitado dentro del editor de bloques. Devuelve las opciones que aparecen en el desplegable después de que el usuario seleccione la fuente de binding («Estado del tiempo» en nuestro ejemplo). Este método está disponible desde WordPress 6.9.getFieldsListdevuelve las opciones que aparecen en el desplegable después de que el usuario seleccione la fuente de binding («Condiciones meteorológicas» en nuestro ejemplo).
Guarda el archivo y vuelve al editor. Tu fuente Weather Conditions (Condiciones Meteorológicas) está ahora disponible en la interfaz del editor, junto a Post Meta. Vuelve a cargar la página y conecta un bloque Párrafo o Encabezado a tu fuente binding. La imagen siguiente muestra el resultado.
La imagen final muestra el resultado en el frontend del sitio web.
¿Qué más puedes hacer con la API Block Bindings?
Este artículo solo aborda superficialmente lo que puedes crear con la API Block Bindings. Lo mejor es que el desarrollo de esta potente funcionalidad de WordPress está lejos de haber terminado, y podemos esperar nuevas implementaciones y novedades en el futuro.
La integración de la API Block Bindings con otras potentes APIs de WordPress, como la API Interactivity, te permite crear aplicaciones dinámicas e interactivas que van mucho más allá de las funciones tradicionales de blogging que hicieron popular a WordPress en sus primeros años.
WordPress ya no es solo una plataforma de blogs o un creador de sitios web. Ahora está destinado a convertirse en una plataforma de desarrollo multipropósito para todo tipo de aplicaciones web.
Cuanto más potentes sean tus aplicaciones, más importante será tu servicio de alojamiento. Kinsta ofrece alojamiento administrado Premium con alto rendimiento, seguridad robusta, automatización extensiva y soporte de primera categoría reconocido como líder del sector por los usuarios de G2.
Las aplicaciones web más potentes requieren la mejor infraestructura de alojamiento. Echa un vistazo a los planes de Kinsta para encontrar el que mejor se adapte a las necesidades de tu sitio.
