Plugins Plugin hub Backup SEO Caching Security Forms WooCommerce Images Best backup plugins
Hosting Hosting directory Shared Managed Cloud India
Themes & builders Compare Rank Math vs Yoast
Tools All tools Hosting finder Plugin stack builder Cost calculator Salt generator Theme detector Who is hosting this? Speed test Headline analyzer robots.txt generator Redirect generator Uptime calculator Blog name generator
Best lists Best backup plugins Deals
Guides All guides Speed up WordPress Choose hosting Back up WordPress
How we test

Explainers · Explainer

What Is the Block Bindings API? A Plain Explanation

Short answer

The Block Bindings API is a WordPress feature that connects a block attribute, such as a paragraph's text or an image's URL, to a live data source such as a custom field. When the stored value changes, every bound block shows the new value without manual edits. It has been part of WordPress core since version 6.5, released in April 2024.

Key takeaways

  • The Block Bindings API links block attributes to live data sources instead of storing fixed text inside each block.
  • It needs WordPress 6.5 or later, and the editor Attributes panel for visual binding arrived in WordPress 6.7.
  • Four built-in sources ship with WordPress: post meta, post data, term data, and pattern overrides.
  • A custom field must be registered with show_in_rest set to true before a block can bind to it.
  • Only 7 core blocks support bindings by default, and each block allows only specific attributes.
  • Developers can register a custom source with register_block_bindings_source() on the init hook.

What is the Block Bindings API?

The Block Bindings API is a WordPress feature that links a block attribute to a live data source, so the block shows the current value each time the page loads.

It arrived in WordPress 6.5, released April 2, 2024, and the Block Editor Handbook states that it is only available for WordPress 6.5 and above (checked November 2026).

Think of a block as a display frame and the source as the shelf behind it. The block keeps its design settings, while the text, link, or image comes from the source. Change the source value once, and every bound block updates.

This matters most for sites that repeat the same facts in many places. A price, a date, a speaker name, or a product link can live in one field instead of being typed into 20 blocks.

How does the Block Bindings API work?

A binding is a small declaration stored in a block's metadata.bindings setting that names a source and the value it should fetch.

When WordPress renders the page, it reads that declaration, calls the source, and replaces the block attribute with the returned value. The Block Editor Handbook explains that the bound value appears in the final HTML sent to the browser.

The stored text inside the block still exists as a fallback. If the source returns no value, the block shows the text you typed.

A simple binding looks like this:

"metadata": {
    "bindings": {
        "content": {
            "source": "core/post-meta",
            "args": { "key": "my_custom_field" }
        }
    }
}

In this example, the paragraph shows the value of the my_custom_field custom field. The source is core/post-meta, and the key argument names the field.

Which blocks and attributes support bindings?

Only 7 core blocks support bindings by default, and each one allows only a short list of attributes.

The Block Editor Handbook lists the default set, and it is smaller than many people expect (checked November 2026).

BlockAttributes you can bind
Image (core/image)id, url, title, alt, caption
Heading (core/heading)content
Paragraph (core/paragraph)content
Button (core/button)url, text, linkTarget, rel
Navigation Link (core/navigation-link)url
Navigation Submenu (core/navigation-submenu)url
Post Date (core/post-date)datetime

That list explains why bindings feel limited at first. You can bind a heading's words, but not its level, and you can bind a button's link and label, but not its color.

WordPress 6.9 added a filter, block_bindings_supported_attributes, that lets developers add more attributes or add support for custom blocks. The handbook notes that this filter also affects pattern overrides, since both features share the same supported-attributes list.

What data can WordPress bind to without extra code?

WordPress ships 4 built-in binding sources, so you can use bindings without writing a custom source.

The Block Editor Handbook names all 4 sources (checked November 2026).

SourceWhat it provides
core/post-metaA custom field on the current post
core/post-dataPost date, modified date, or permalink
core/term-dataTerm name, link, slug, description, count, or parent
core/pattern-overridesA per-instance value inside a synced pattern

The core/post-meta source is the one most sites use first. It reads a post meta field, which is the stored value behind a custom field.

The core/post-data source covers 3 fields: date, modified, and link. The core/term-data source covers 7 fields, including name, slug, and count, and it needs term context from the block around it.

For term data, the category or tag must be in context. A guide to categories and tags explains how WordPress groups posts with taxonomies, and that grouping is what term context describes.

What is a custom data feed for bindings?

A custom binding source is a named data feed that a plugin or theme registers, so blocks can pull values from anywhere, not just post meta.

Registration needs at least a name, a label, and a callback function that returns the value. The function reference for register_block_bindings_source() says the function was introduced in WordPress 6.5.0 and should be called from a handler attached to the init hook.

The callback receives 3 arguments: source_args, block_instance, and attribute_name. WordPress runs it when the bound block renders, then places the returned value into the attribute.

Custom sources can return values from user data, site options, a computed result, or an outside service. The handbook gives an example of an Image block url bound to a function that returns random images from an outside API.

You can register a source in PHP for the front end, in JavaScript for the editor, or both. The PHP side decides what visitors see, while the JavaScript side decides what editors see and whether they can edit the value in place.

How did Block Bindings change in WordPress 6.6, 6.7, and 6.9?

Block Bindings arrived as a developer-only tool in WordPress 6.5, then gained editor features in each later release.

WordPress 6.5 shipped with no binding UI, so bindings had to be added by hand in the Code Editor. The Make WordPress Core dev note for 6.5 says there was no UI for binding attributes to custom fields yet in that first version.

WordPress 6.6 added 2 visible changes. Synced pattern overrides let a reused pattern keep one design while some blocks show different text per use. The Make WordPress Core post on editing custom fields from connected blocks says 6.6 also let editors change a custom field value directly from the bound block.

WordPress 6.7, released November 12, 2024, added the Attributes panel in block settings. The Make WordPress Core dev note for 6.7 says compatible blocks, including Heading, Paragraph, Image, and Button, gained a panel that shows active bindings and lets you bind attributes to custom fields.

WordPress 6.7 also added the public JavaScript API, including registerBlockBindingsSource, getBlockBindingsSource, and getBlockBindingsSources. Before 6.7, custom sources could only be registered on the server in PHP.

WordPress 6.9 widened the API further. It added the core/post-data and core/term-data sources, the block_bindings_supported_attributes filter, and a getFieldsList method that lets custom sources appear in the editor dropdown.

ReleaseChange
6.5 (April 2, 2024)API launched; core/post-meta only; no editor UI
6.6 (July 2024)Synced pattern overrides; edit field values from bound blocks
6.7 (November 12, 2024)Attributes panel; public JavaScript API
6.9core/post-data and core/term-data; supported-attributes filter; getFieldsList

What can you build with Block Bindings?

You can build pages where facts update in one place instead of being retyped in every block.

A book review site is the example the WordPress Developer Blog uses. In Introducing Block Bindings, part 1, a paragraph shows a book price stored as a custom field, so changing the price updates the page.

Common uses include:

  • A product price or stock note stored as a custom field and shown in several blocks
  • An event date, venue, or speaker name reused across a schedule page
  • A call-to-action button whose link comes from a field, so one edit retargets every copy
  • A term archive list where each item shows the live category name and post count
  • A synced pattern, such as a testimonial card, with a different quote in each use

How can you check Block Bindings on your site?

You can check for bindings in 3 places: your WordPress version, the editor, and the block markup.

First, confirm the version. Go to Dashboard, then Updates, and check that your site runs WordPress 6.5 or later. Bindings do not exist on older versions, and the Attributes panel needs 6.7 or later.

Second, open a post in the editor and select a Paragraph, Heading, Image, or Button block. In WordPress 6.7 or later, the block settings sidebar shows an Attributes panel that lists active bindings and available custom fields.

Third, switch to the Code Editor and look for metadata.bindings in the block markup. A block with no metadata setting has no binding, even if its text matches a field value.

If the Attributes panel shows no fields, the field may not be registered for the editor. A custom field must be registered with show_in_rest set to true, and keys that start with an underscore are protected and cannot be used.

What are common myths about Block Bindings?

Several myths make bindings sound bigger, or smaller, than they are.

Myth 1: Bindings work on every block

They do not. Only 7 core blocks support bindings by default, and the handbook lists the exact attributes for each. Other blocks need the 6.9 filter or a custom block that opts in.

Myth 2: Bindings store the value in the block

They do not. The value stays in its source, such as a custom field, and the block fetches it when the page renders. Editing the block text does not change the stored field.

Myth 3: Bindings replace custom fields plugins

They do not. Bindings read fields; they do not create the field screens or the storage.

Plugins such as Advanced Custom Fields add their own binding support on top of the core API. ACF 6.8.1 added full support for the API, and its docs list WordPress 6.7 or later as a requirement.

Myth 4: Bindings are only for developers

They were in 6.5, but not now. Since WordPress 6.7, editors can bind a block to a custom field from the Attributes panel without touching code. Developers are still needed to register the field or a custom source.

Myth 5: A bound block is locked forever

It is not. A bound block shows the source value and limits direct text editing, but you can remove the binding from the Attributes panel or by deleting the metadata.bindings setting. The block then goes back to showing its stored text.

What mistakes should you avoid?

Avoid the 5 mistakes that cause most binding failures.

  • Binding to an unregistered field. Register the meta with show_in_rest set to true first, or the field will not appear in the editor.
  • Using an underscore key. Keys that start with _ are protected, so pick a public key name.
  • Binding an unsupported attribute. Check the supported list first, since binding a heading level or a block color does nothing by default.
  • Forgetting the version. The API needs 6.5, the Attributes panel needs 6.7, and the filter and extra sources need 6.9 (checked November 2026).
  • Hiding the source in a theme file. A custom source registered only in one theme stops working when you switch themes. Put shared sources in a small plugin instead, since themes and plugins have different jobs.

If a binding shows nothing on the front end, check the version, the field registration, and the attribute name, in that order. Most failures come from one of those 3 points, not from the binding itself.

A separate guide covers the practical steps. The block editor compared with page builders puts the editor itself in context.

Frequently asked questions

Do I need to know code to use Block Bindings?

No, not for the basic use. Since WordPress 6.7, you can bind a Paragraph, Heading, Image, or Button block to a custom field from the Attributes panel in the block settings sidebar. You need a developer only to register the custom field or to build a custom source that pulls data from somewhere other than post meta.

Can Block Bindings show data from another website or service?

Yes, through a custom source. A developer registers a source with a callback that fetches the value, for example from an outside API or a site option, and blocks bind to that source by name. The core sources only cover post meta, post data, term data, and pattern overrides, so anything else needs a custom source.

Why does my custom field not appear in the Attributes panel?

The usual cause is registration. The field must be registered with show_in_rest set to true, and its key must not start with an underscore, since protected keys are hidden from bindings. Also check that you run WordPress 6.7 or later, that the block type supports bindings, and that the field type matches the attribute type.

Do bound blocks slow down a WordPress site?

Bindings add a small amount of work at render time, because WordPress calls the source callback for each bound attribute before sending the page. For fields stored in the database, that cost is small. A custom source that calls a slow outside service on every page load can add delay, so cache those values instead of fetching them live each time.

What happens to bindings if I switch themes?

Bindings stored in post content stay in place, but they only work if their source still exists. Built-in sources such as core/post-meta keep working. A custom source registered by your old theme stops working after a switch, so the bound blocks fall back to their stored text. Keep shared sources in a plugin to avoid this.

Sources

  1. Bindings WordPress Developer Resources
  2. register_block_bindings_source() WordPress Developer Resources
  3. Introducing Block Bindings, part 1: connecting custom fields WordPress Developer Blog
  4. Getting and setting Block Binding values in the Editor WordPress Developer Blog
  5. Editing custom fields from connected blocks Make WordPress Core
  6. Version 6.5 WordPress.org
  7. Block Bindings Advanced Custom Fields

Is your product missing, or something out of date?

Tell us what to add or correct. We read every note and reply when we need a source. A message does not buy a ranking.

About the editors

WPLegible editors

Researched from the primary sources listed above and checked against our editorial rules. About the site · How we test