Advanced Custom Fields vs Block Bindings: Contenido Dinámico en WordPress

La evolución del contenido dinámico en WordPress

Durante más de una década, Advanced Custom Fields (ACF) ha sido la solución de referencia para gestionar contenido dinámico en WordPress. Pero desde WordPress 6.5, una nueva característica nativa está cambiando las reglas del juego: la Block Bindings API. En este artículo, exploraremos ambas soluciones, sus diferencias, casos de uso, y te ayudaremos a decidir cuál es la mejor opción para tu proyecto en 2026.

¿Qué es Advanced Custom Fields (ACF)?

ACF es un plugin premium que transforma WordPress en un sistema completo de gestión de contenidos. Permite añadir campos personalizados a posts, páginas, usuarios, taxonomías y prácticamente cualquier parte de WordPress con una interfaz visual intuitiva.

Las fortalezas de ACF

1. Más de 30 tipos de campos

ACF ofrece una biblioteca extensísima de tipos de campos:

• Campos básicos: texto, textarea, number, email, URL
• Campos de contenido: WYSIWYG, oembed, imagen, galería
• Campos de selección: select, checkbox, radio, true/false
• Campos relacionales: relationship, post object, page link, taxonomy
• Campos avanzados (PRO): repeater, flexible content, clone, gallery

2. Interfaz visual completa

No necesitas tocar código para crear campos. Todo se gestiona desde una interfaz drag-and-drop:

// Aunque también puedes registrar campos por código
acf_add_local_field_group([
    'key' => 'grupo_evento',
    'title' => 'Detalles del Evento',
    'fields' => [
        [
            'key' => 'field_fecha',
            'label' => 'Fecha del evento',
            'name' => 'fecha_evento',
            'type' => 'date_picker',
        ],
        [
            'key' => 'field_ubicacion',
            'label' => 'Ubicación',
            'name' => 'ubicacion',
            'type' => 'google_map',
        ],
    ],
    'location' => [
        [
            [
                'param' => 'post_type',
                'operator' => '==',
                'value' => 'evento',
            ],
        ],
    ],
]);

3. ACF Blocks (PRO)

Uno de los features más potentes de ACF PRO es la capacidad de crear bloques de Gutenberg personalizados sin JavaScript:

// Registrar un bloque ACF
acf_register_block_type([
    'name' => 'testimonial',
    'title' => __('Testimonial'),
    'description' => __('Un bloque de testimonial personalizado'),
    'render_template' => 'template-parts/blocks/testimonial.php',
    'category' => 'formatting',
    'icon' => 'admin-comments',
    'keywords' => ['testimonial', 'quote'],
    'supports' => [
        'align' => true,
        'mode' => true,
    ],
]);

Y el template:

<?php
// template-parts/blocks/testimonial.php
$nombre = get_field('nombre');
$empresa = get_field('empresa');
$testimonio = get_field('testimonio');
$foto = get_field('foto');
?>

<div class="testimonial">
    <?php if ($foto): ?>
        <img src="<?php echo esc_url($foto['url']); ?>" alt="<?php echo esc_attr($nombre); ?>">
    <?php endif; ?>
    <blockquote><?php echo esc_html($testimonio); ?></blockquote>
    <cite><?php echo esc_html($nombre); ?>, <?php echo esc_html($empresa); ?></cite>
</div>

4. API simple y poderosa

Mostrar campos es extremadamente sencillo:

// En cualquier template
<?php
// Campo simple
$titulo = get_field('titulo');
echo $titulo;

// Campo de imagen
$imagen = get_field('imagen_destacada');
if ($imagen): ?>
    <img src="<?php echo esc_url($imagen['url']); ?>" 
         alt="<?php echo esc_attr($imagen['alt']); ?>">
<?php endif; ?>

// Campo repeater (PRO)
if (have_rows('galeria')): 
    while (have_rows('galeria')): the_row(); 
        $imagen = get_sub_field('imagen');
        $descripcion = get_sub_field('descripcion');
        ?>
        <figure>
            <img src="<?php echo esc_url($imagen['url']); ?>">
            <figcaption><?php echo esc_html($descripcion); ?></figcaption>
        </figure>
    <?php endwhile; 
endif; ?>

¿Qué es la Block Bindings API?

La Block Bindings API es una característica nativa de WordPress introducida en la versión 6.5 (marzo 2024) que permite vincular atributos de bloques a fuentes de datos dinámicas sin necesidad de plugins.

Cómo funciona Block Bindings

Block Bindings conecta los atributos de un bloque (como el contenido de un párrafo o la URL de una imagen) a una fuente de datos registrada. Cuando se renderiza la página, el bloque muestra automáticamente el contenido de esa fuente.

Bloques compatibles en WordPress 6.9:

Bloque	Atributos compatibles
Heading	content
Paragraph	content
Button	text, url, linkTarget, rel
Image	url, alt, title

Ejemplo básico: Vinculando un campo personalizado

1. Registrar un custom field:

// En functions.php o en tu plugin
function mi_tema_registrar_meta() {
    register_post_meta('post', 'subtitulo', [
        'show_in_rest' => true,
        'single' => true,
        'type' => 'string',
        'default' => '',
    ]);
}
add_action('init', 'mi_tema_registrar_meta');

2. Vincular un bloque al campo:

En el editor de bloques, añade un bloque de párrafo y en el modo código añade el atributo de binding:

<!-- wp:paragraph {
    "metadata": {
        "bindings": {
            "content": {
                "source": "core/post-meta",
                "args": {
                    "key": "subtitulo"
                }
            }
        }
    }
} -->
<p></p>
<!-- /wp:paragraph -->

Ahora, ese párrafo mostrará automáticamente el valor del campo subtitulo en el frontend, y en el editor aparecerá bloqueado con un indicador de que está vinculado.

Interfaz visual en WordPress 6.6+

Desde WordPress 6.6, ya existe una interfaz visual para gestionar los bindings. En el panel de configuración del bloque, aparece una sección "Attributes" donde puedes seleccionar campos personalizados disponibles.

Creando fuentes personalizadas con Block Bindings

Una de las características más potentes de Block Bindings es la capacidad de crear tus propias fuentes de datos:

// Registrar una fuente personalizada
function mi_tema_registrar_binding_source() {
    register_block_bindings_source('mi-tema/autor-info', [
        'label' => __('Información del Autor', 'mi-tema'),
        'get_value_callback' => 'mi_tema_obtener_autor_info',
        'uses_context' => ['postId'],
    ]);
}
add_action('init', 'mi_tema_registrar_binding_source');

// Callback para obtener el valor
function mi_tema_obtener_autor_info($source_args, $block_instance, $attribute_name) {
    $post_id = $block_instance->context['postId'];
    $author_id = get_post_field('post_author', $post_id);
    
    if ($attribute_name === 'content') {
        $author_name = get_the_author_meta('display_name', $author_id);
        $author_posts = count_user_posts($author_id);
        return sprintf(
            '%s - %d artículos publicados',
            $author_name,
            $author_posts
        );
    }
    
    return '';
}

Uso en el editor:

<!-- wp:paragraph {
    "metadata": {
        "bindings": {
            "content": {
                "source": "mi-tema/autor-info"
            }
        }
    }
} -->
<p></p>
<!-- /wp:paragraph -->

Comparación directa: ACF vs Block Bindings

1. Facilidad de uso

ACF gana en:

• Interfaz visual completa y madura
• No requiere conocimientos de código para uso básico
• Documentación extensa (más de 10 años)
• Gran comunidad y soporte

Block Bindings gana en:

• Nativo de WordPress (no requiere plugins)
• Integración perfecta con el editor de bloques
• Actualizaciones automáticas con WordPress core

Veredicto: ACF es más accesible para principiantes, Block Bindings es más elegante para desarrolladores.

2. Flexibilidad de campos

ACF:

• 30+ tipos de campos predefinidos
• Campos relacionales complejos
• Repeater y Flexible Content (PRO)
• Gallery field (PRO)
• Options pages (PRO)

Block Bindings:

• Solo funciona con atributos de bloques existentes
• Limitado a text, URL, alt, title
• Requiere código PHP para fuentes personalizadas

Veredicto: ACF es mucho más versátil en tipos de datos. Block Bindings está limitado a lo que los bloques core soportan.

3. Rendimiento

ACF:

• Plugin adicional (aumenta peso del sitio)
• Queries adicionales a la base de datos
• Caché necesario para sitios de alto tráfico

Block Bindings:

• Nativo, sin overhead de plugins
• Integrado en el rendering de bloques
• Más eficiente en teoría

Veredicto: Block Bindings tiene ventaja técnica, pero la diferencia es mínima en la práctica.

4. Casos de uso específicos

ACF es mejor para:

// Ejemplo: Portfolio con galería de imágenes
// (Repeater field - solo PRO)
<?php if (have_rows('portfolio_items')): ?>
    <div class="portfolio-grid">
        <?php while (have_rows('portfolio_items')): the_row(); ?>
            <div class="portfolio-item">
                <img src="<?php echo get_sub_field('imagen')['url']; ?>">
                <h3><?php the_sub_field('titulo'); ?></h3>
                <p><?php the_sub_field('descripcion'); ?></p>
                <a href="<?php the_sub_field('url_proyecto'); ?>">Ver proyecto</a>
            </div>
        <?php endwhile; ?>
    </div>
<?php endif; ?>

Block Bindings es mejor para:

// Ejemplo: Mostrar dinámicamente el título SEO
function mi_tema_seo_title_source() {
    register_block_bindings_source('mi-tema/seo-title', [
        'label' => 'Título SEO',
        'get_value_callback' => function($source_args, $block_instance) {
            $post_id = $block_instance->context['postId'];
            $seo_title = get_post_meta($post_id, 'yoast_wpseo_title', true);
            return $seo_title ?: get_the_title($post_id);
        },
    ]);
}
add_action('init', 'mi_tema_seo_title_source');

5. Integración con el Block Editor

ACF Blocks:

// Requiere crear template PHP separado
// Mayor control sobre HTML y estilos
// Puede ser más complejo de mantener
acf_register_block_type([
    'name' => 'hero',
    'title' => 'Hero Section',
    'render_template' => 'blocks/hero.php',
    'enqueue_style' => get_template_directory_uri() . '/blocks/hero.css',
]);

Block Bindings:

// Usa bloques core, más ligero
// Menos control sobre estructura HTML
// Más mantenible a largo plazo
register_block_bindings_source('mi-tema/hero-data', [
    'label' => 'Hero Data',
    'get_value_callback' => 'obtener_hero_data',
]);

Novedades en WordPress 6.9 (Diciembre 2025)

La Block Bindings API ha recibido mejoras significativas en WordPress 6.9:

1. Interfaz mejorada

Los usuarios ahora pueden cambiar fácilmente entre fuentes diferentes y vincular o desvincular atributos con un solo clic.

2. Nuevo filtro para atributos compatibles

// Hacer cualquier atributo de bloque compatible con bindings
add_filter('block_bindings_supported_attributes', function($attributes, $block_name) {
    if ($block_name === 'core/button') {
        $attributes[] = 'backgroundColor'; // Ahora backgroundColor puede ser dinámico
    }
    return $attributes;
}, 10, 2);

3. Método getFieldsList para fuentes personalizadas

Ahora puedes registrar tus propias fuentes de datos añadiendo un método getFieldsList() en el registro de la fuente:

register_block_bindings_source('mi-plugin/api-data', [
    'label' => 'API Data',
    'get_value_callback' => 'obtener_api_data',
    'get_fields_list' => function() {
        return [
            [
                'name' => 'title',
                'label' => 'API Title',
            ],
            [
                'name' => 'description',
                'label' => 'API Description',
            ],
        ];
    },
]);

Combinando ACF y Block Bindings

Lo mejor de todo es que no tienes que elegir solo uno. Puedes usar ACF para gestionar campos complejos y Block Bindings para mostrarlos en bloques:

// 1. Crear campos con ACF (via UI o código)
// Campo: 'precio_producto' en custom post type 'producto'

// 2. Crear una fuente de Block Bindings que lee campos ACF
function mi_tema_acf_binding_source() {
    register_block_bindings_source('mi-tema/acf-fields', [
        'label' => 'ACF Fields',
        'get_value_callback' => function($source_args, $block_instance, $attribute_name) {
            if (!isset($source_args['key'])) {
                return '';
            }
            
            $post_id = $block_instance->context['postId'];
            return get_field($source_args['key'], $post_id);
        },
    ]);
}
add_action('init', 'mi_tema_acf_binding_source');

// 3. Usar en el editor
// Ahora puedes vincular cualquier campo ACF a bloques

Casos de uso reales

Caso 1: Sitio de Bienes Raíces

Con ACF:

// Campo Group: Detalles Propiedad
// - precio (number)
// - habitaciones (number)
// - baños (number)
// - metros_cuadrados (number)
// - galeria (gallery - PRO)
// - caracteristicas (repeater - PRO)
//   - caracteristica (text)
//   - icono (image)

// Template
<?php
$precio = get_field('precio');
$habitaciones = get_field('habitaciones');
?>
<div class="propiedad-header">
    <h2><?php the_title(); ?></h2>
    <div class="precio">$<?php echo number_format($precio); ?></div>
    <div class="specs">
        <span><?php echo $habitaciones; ?> hab.</span>
        <span><?php echo get_field('baños'); ?> baños</span>
        <span><?php echo get_field('metros_cuadrados'); ?> m²</span>
    </div>
</div>

<?php if (have_rows('caracteristicas')): ?>
    <ul class="caracteristicas">
        <?php while (have_rows('caracteristicas')): the_row(); ?>
            <li>
                <img src="<?php echo get_sub_field('icono')['url']; ?>">
                <?php the_sub_field('caracteristica'); ?>
            </li>
        <?php endwhile; ?>
    </ul>
<?php endif; ?>

Con Block Bindings:

// Registrar meta fields simples
register_post_meta('propiedad', 'precio', [
    'show_in_rest' => true,
    'type' => 'number',
]);

// Fuente personalizada para formato de precio
register_block_bindings_source('inmobiliaria/precio-formato', [
    'label' => 'Precio Formateado',
    'get_value_callback' => function($source_args, $block) {
        $precio = get_post_meta($block->context['postId'], 'precio', true);
        return '$' . number_format($precio);
    },
]);

// En el editor: vincular un bloque Heading al precio formateado

Caso 2: Directorio de Restaurantes

Ventaja ACF: El campo Google Map

<?php
$ubicacion = get_field('ubicacion_restaurante');
if ($ubicacion): ?>
    <div class="acf-map" data-zoom="16">
        <div class="marker" 
             data-lat="<?php echo esc_attr($ubicacion['lat']); ?>" 
             data-lng="<?php echo esc_attr($ubicacion['lng']); ?>">
            <h4><?php the_title(); ?></h4>
            <p><?php echo esc_html($ubicacion['address']); ?></p>
        </div>
    </div>
<?php endif; ?>

Block Bindings no tiene equivalente nativo para esto. Necesitarías un custom block o usar ACF.

Caso 3: Blog Personal con metadatos

Block Bindings es perfecto:

// Tiempo de lectura calculado automáticamente
register_block_bindings_source('blog/reading-time', [
    'label' => 'Tiempo de Lectura',
    'get_value_callback' => function($source_args, $block) {
        $post_id = $block->context['postId'];
        $content = get_post_field('post_content', $post_id);
        $word_count = str_word_count(strip_tags($content));
        $minutes = ceil($word_count / 200);
        return sprintf('%d min de lectura', $minutes);
    },
]);

Tabla de decisión: ¿Cuál elegir?

Necesitas...	ACF	Block Bindings
Campos complejos (repeater, flexible content)	✅ Sí	❌ No
Galería de imágenes	✅ Sí (PRO)	❌ No
Google Maps	✅ Sí	❌ No
Options Pages	✅ Sí (PRO)	❌ No
Interfaz visual completa	✅ Sí	🟡 Parcial
Solución nativa (sin plugins)	❌ No	✅ Sí
Actualizaciones automáticas	🟡 Manual	✅ Con WP
Campos simples (text, number)	✅ Sí	✅ Sí
Integración con bloques core	🟡 Via ACF Blocks	✅ Nativa
Curva de aprendizaje	🟡 Media	🔴 Alta
Coste	💰 $49-249/año	✅ Gratis

Recomendaciones para 2026

Usa ACF si:

• Necesitas crear sitios complejos con campos avanzados
• Trabajas con clientes que necesitan una UI intuitiva
• Requieres repeaters, flexible content, galleries
• Ya tienes experiencia con ACF
• El presupuesto permite ACF PRO

Usa Block Bindings si:

• Estás construyendo un tema block-based moderno
• Solo necesitas campos simples vinculados a bloques
• Prefieres soluciones nativas de WordPress
• Quieres mantener tu sitio liviano
• Te sientes cómodo escribiendo código PHP

Usa ambos si:

• Necesitas lo mejor de ambos mundos
• ACF para gestionar campos complejos
• Block Bindings para mostrarlos en bloques nativos
• Quieres flexibilidad máxima

El futuro: Hacia dónde vamos

La Block Bindings API está madurando rápidamente. En WordPress 6.9 y futuras versiones, esperamos ver:

1. Más bloques compatibles: Soporte para Query Loop, Navigation, y bloques de terceros
2. Interfaz visual mejorada: UI más intuitiva para gestionar bindings
3. Tipos de datos más ricos: Soporte para arrays, objetos, y relaciones
4. Mejor documentación: Más ejemplos y guías oficiales

Por su parte, ACF continúa siendo fundamental para proyectos complejos y ha introducido mejoras en ACF Blocks V3 con edición inline.

---

🚀 ¡Comparte este artículo!
Si te ha resultado útil, compártelo con otros desarrolladores que puedan beneficiarse.

---

Conclusión

No hay una respuesta única. ACF sigue siendo la herramienta más completa y madura para gestionar campos personalizados complejos en WordPress. Es especialmente valiosa si necesitas repeaters, flexible content, o una interfaz visual completa para clientes.

Block Bindings, por otro lado, representa el futuro nativo de WordPress. Es perfecto para sitios block-based modernos que necesitan contenido dinámico simple sin añadir plugins adicionales.

La mejor estrategia en 2026 podría ser híbrida: usar ACF para gestionar campos complejos y Block Bindings para integrarlos elegantemente con el editor de bloques. Así combinas la potencia de ACF con la elegancia nativa de WordPress.

¿Qué solución elegirás para tu próximo proyecto?

---

💡 ¿Necesitas ayuda con tu proyecto?
Si quieres que te ayude con tu proyecto web, no tienes más que ponerte en contacto. Estaré encantado de ayudarte.

---