WooCommerce Hook Priority: Execution Order & Best Practices

This article was last manually reviewed for data accuracy on 12 November 2025.

Customizing WooCommerce is the foundation of building unique, robust e-commerce sites. While themes and settings cover basic styling, advanced functionality—such as custom product pricing, third-party API integration, or modifying the checkout process—requires interacting directly with the platform’s core logic.

This interaction is done exclusively through WooCommerce Hooks (Actions and Filters).

What Is WooCommerce Hook Priority & Why It Matters

Hooks are specific placeholders inserted by the core developers that allow external functions (from plugins or themes) to “hook in” and perform tasks or manipulate data.

1. Actions: Allow you to do something at a particular moment in the code execution (e.g., adding a custom field to the product page).
2. Filters: Allow you to modify data before it’s used or displayed (e.g., changing the final price of an item).

Hooks ensure your customizations are non-destructive, meaning you never need to edit WooCommerce core files, preserving your work across updates.

For a deep dive: Read WooCommerce Hooks and Filters: Complete Guide with Examples

Why Hook Priority Prevents Conflicts

In a typical WooCommerce environment, you might have several functions—from the core platform, the active theme, and multiple plugins—all attached to the same hook.

• A tax plugin might filter the price.
• A loyalty program plugin might filter the price.
• Your custom code might filter the price.

If all three functions run without a specified order, the final result is unpredictable, leading to bugs like incorrect pricing, missing content, or validation errors.

Priority solves this by establishing a predictable, reliable execution order, guaranteeing that your crucial customizations run precisely when they need to.

Understanding WooCommerce Hooks: Actions vs Filters

While both use the same syntax, their function and data handling are fundamentally different.

Action Hooks & Priority (do_action / add_action)

Purpose: To execute a task when a certain event occurs.

Execution Flow: Functions attached to actions execute sequentially based on their priority. They do not accept or return data; they simply perform a standalone task (e.g., displaying HTML, logging data, or sending an email).

Syntax Example (Adding content below the “Add to Cart” button):

// WooCommerce core runs: do_action( 'woocommerce_after_add_to_cart_button' );

add_action( 'woocommerce_after_add_to_cart_button', 'my_custom_content_function', 15 );
function my_custom_content_function() {
    echo '<p class="trust-badge">🔒 Secure Checkout Guaranteed</p>';
}

Filter Hooks & Hook Priority (apply_filters and add_filter)

Purpose: To modify a piece of data (a variable) before it is returned and used by the calling code.

Execution Flow: Filter functions run sequentially, passing the data as an argument. The key requirement is that a filter function must always accept the original value and explicitly return the modified (or unmodified) value. The output of one filter function becomes the input of the next.

Syntax Example (Modifying the price display text):

// WooCommerce core runs: $price_html = apply_filters( 'woocommerce_get_price_html', $price_html, $product );

add_filter( 'woocommerce_get_price_html', 'append_tax_note_to_price', 10, 2 );

function append_tax_note_to_price( $price_html, $product ) {
    // Modify the price HTML only if it's a simple product
    if ( $product->is_type( 'simple' ) ) {
        $price_html .= ' <small>(Inc. Local VAT)</small>';
    }
    return $price_html; // Must return the modified value
}

Demystifying WooCommerce Hook Priority Parameter

The priority parameter is the mechanism for control. Without it, the execution order is simply the order in which PHP loads the functions, which is unreliable.

Syntax: Where Hook Priority Fits (add_action / add_filter)

The priority is the third argument in both hook functions:

add_action( $hook_name, $callback_function, $priority, $accepted_args );
add_filter( $hook_name, $callback_function, $priority, $accepted_args );

Default Priority (10) — What It Means for Hook Priority

If you omit the $priority parameter, it defaults to 10.

Most core WooCommerce functions (like displaying the product title, price, or description) are attached at priority 10. This priority is considered the “standard” execution time.

Execution Rule: Lower Numbers Run First

The rule is straightforward and critical to remember: Lower numbers execute first.

• Low Priority (1 to 9): Runs BEFORE the default 10. Use this when you need your code to initialize variables, prepare data, or run essential logic before core WooCommerce functions execute.
• Default Priority (10): Runs in the middle. Most plugins use this.
• High Priority (11 to 999+): Runs AFTER the default 10. Use this when you need to override other plugins, apply final formatting, or guarantee your change is the very last one applied to a value or piece of content.

Tie-Breaker Rule: Same Priority Order & Hook Priority Pitfalls

If multiple functions are attached to the same hook with the same priority number (e.g., four different functions all set to priority 10), they will execute in the order that they were encountered (registered) by the PHP interpreter.

This is why relying solely on 10 can still lead to unpredictability if you depend on another plugin running before or after your code.

Practical Use Cases of WooCommerce Hook Priority

Using specific priority numbers is a sign of an experienced WooCommerce developer.

Overriding Defaults Using The Priority (High Priority Examples)

To ensure your code executes last and overrides any conflicting logic from other plugins (often necessary when dealing with price filters).

Scenario: You have a custom fee applied to the cart total, and you need to ensure no other functions can modify the cart total after your fee is added.

// Use a very high number (e.g., 9999) to run absolutely last.

add_filter( 'woocommerce_get_price_including_tax', 'guarantee_final_price', 9999, 3 );

function guarantee_final_price( $price, $qty, $product ) {
    // Final check or modification
    $final_price = $price * 1.05; // Example: Add a 5% handling fee
    return $final_price;
}

Running Code Early with Hook Priority (Low Priority Examples)

To prepare the environment or validate data before core WooCommerce logic takes place.

Scenario: You need to validate a specific custom checkout field before WooCommerce’s default checkout_process runs, to ensure a third-party API call can be made successfully early in the flow.

// Use a low number (e.g., 1) to run before the core validation (usually 10).

add_action( 'woocommerce_checkout_process', 'early_api_data_validation', 1 );
function early_api_data_validation() {
    if ( empty( $_POST['custom_field_api_key'] ) ) {
        wc_add_notice( 'Please enter your API key before proceeding.', 'error' );
    }
}

Move & Reattach Elements — Unhooking with Hook Priority

Priority is essential when you want to move a core element—like the product price—to a different location on the single product page. You must use the correct priority to successfully remove_action before you can add_action it again.

Scenario: Move the product price display from its default location to immediately after the product title.

// 1. Identify where it's currently attached: woocommerce_single_product_summary at priority 10.

// 2. Remove the original action. You MUST specify the original function name AND the original priority.

remove_action( 'woocommerce_single_product_summary', 'woocommerce_template_single_price', 10 );

// 3. Add the action back in with a new, early priority (e.g., 6).
// The title is usually at priority 5, so 6 places the price right after it.

add_action( 'woocommerce_single_product_summary', 'woocommerce_template_single_price', 6 );

Note: If you omitted the 10 in the remove_action call, the function would fail to unhook.

WooCommerce Hook Priority & Execution Order in the Lifecycle

Understanding the sequence of hooks, regardless of priority, is key to choosing the correct hook name.

Product Page Flow: Using Hook Priority on single_product_summary

This action hook is a container for displaying most product details. The default elements attached to it run sequentially:

If you want to place a custom badge between the Title and the Price, you would attach your function to woocommerce_single_product_summary with a priority of 7 or 8.

Checkout Flow & Hook Priority — Where to Hook Critical Logic

The checkout process involves several critical, sequential hooks for validation, creation, and final confirmation:

1. Display Hooks: woocommerce_before_checkout_form and woocommerce_after_checkout_form are used for displaying content.
2. Order Creation Hook: woocommerce_checkout_create_order is a critical action that fires just before the order is saved to the database. This is the ideal place to attach meta data or final checks to the order object.
3. Thank You Hook: woocommerce_thankyou fires on the final confirmation page after the payment is processed, often used for third-party tracking or sending custom notifications.

WordPress Load Order & Hook Priority (plugins_loaded, init, wp_loaded)

WooCommerce customizations must load after the WooCommerce plugin is fully loaded. The hierarchy is:

1. plugins_loaded: Fired when all plugins are active.
2. init: Fired after WordPress is loaded but before headers are sent. This is where most add_action and add_filter calls should be placed to ensure WooCommerce objects and functions are available.
3. wp_loaded: Fired late in the process, ensuring everything is fully set up.

Best Practices for WooCommerce Hook Priority & Troubleshooting

Use Specific Priority Numbers — Clear Conventions for Hook Priority

Never rely solely on the default 10. Use the following conventions to make your code intent clear:

• To force an element early: Use 1 or 5.
• To place content right before the core elements: Use 9.
• To place content right after the core elements: Use 11.
• To guarantee a final override: Use a large number like 9999.

remove_action/remove_filter: How Hook Priority Affects Unhooking

Remember the golden rule for unhooking: You must know the original priority used when the function was attached.

// This will FAIL if the original priority was 5!

remove_action( 'woocommerce_single_product_summary', 'woocommerce_template_single_price', 10 );

Debugging Hook Conflicts — Inspect Priorities to Resolve WooCommerce Issues

If you suspect a conflict, you can inspect the global $wp_filter array (in a staging environment) to see all functions attached to a specific hook and their priorities:

// Example for inspecting the price filter

global $wp_filter;
echo '<pre>';
print_r( $wp_filter['woocommerce_get_price_html'] );
echo '</pre>';

This output will clearly show every function targeting that hook, organized by its priority number, helping you pinpoint the conflict.

Context & Deployment: Where to Put Code When Using Hook Priority

Always place your custom code within a dedicated custom plugin or your child theme’s functions.php file. This is crucial for separating your work from the core platform and the theme itself, ensuring maximum longevity and update safety.

FAQ: WooCommerce Hook Priority – Common Questions

Does Lower Hook Priority Make Code Run Faster?

No. The priority number only dictates the order of execution relative to other functions attached to the same hook; it has no impact on the function’s processing speed or PHP execution time.

What If Two Plugins Share the Same Hook Priority?

If two functions are attached to the same hook with the identical priority, they will execute in the order they were registered by PHP. This is why using very high numbers should be reserved only for cases where you absolutely need the final say. For most organizational tasks, using small offsets (like 11, 15, 20) is safer.

Can You Change Another Plugin’s Hook Priority?

Yes, but it’s tricky. You must first successfully unhook it using remove_action or remove_filter (knowing its original priority and function name), and then immediately re-hook it using add_action or add_filter with your new desired priority. If you fail to unhook it, you will end up running the function twice.

Action vs Filter — Which Should You Use with Priority?

They serve different purposes and are not interchangeable.

• Use an Action when you want to inject data, display content, or save information (i.e., you are doing something).
• Use a Filter when you want to manipulate a specific variable (i.e., you are changing something). If your function doesn’t need to return a value, it shouldn’t be a filter.

Conclusion: Master WooCommerce Hook Priority for Reliable Customisations

Understanding hook priority and execution order is not just about avoiding errors—it’s about gaining absolute control over the WooCommerce application flow.

By strategically using the third argument in your add_action and add_filter calls, you can guarantee predictable results, override conflicting plugins, and build robust, future-proof customizations.

This is how you transform from an amateur to an authoritative WooCommerce developer.