How it works

The feature hooks into the existing Expire functionality (see Create Expiration for License Product ) and lets you modify renewal pricing via the woo_sl/default_expire/renew_price filter. You supply a set of discount rules that map time ranges to discount percentages; when a renewal price is calculated the filter applies the correct discount based on the license’s time-to-expiry or time-since-expiry.

Discount rules format

Rules are passed as an associative array with two top-level sections: before-expire and after-expire. Keys are ranges (days) and values are discount percentages. Example structure:

    $discount_rules = [
                        'before-expire' => [
                            '30-6' => 40,  // between 6 and 30 days before expiry => 40%
                            '5-0'  => 35,   // 0 to 5 days before expiry => 35%
                        ],
                        'after-expire'  => [
                            '0-14'   => 30,  // expired 0 to 14 days => 30%
                            '15-29'  => 25,  // expired 15 to 30 days => 25%
                            '30-180' => 20,  // expired 31 to 180 days => 20%
                            '181-'   => 10,  // expired 181 days or more => 10%
                        ],
                    ];

• Ranges are day intervals. 30-6 means the range between 6 and 30 days before expiration (order can be interpreted by your parser — be consistent).
• 181- means 181 days or more.
• Values are percentages (e.g., 40 = 40% discount).

Where to put the code

You can inject the code inside a custom file on your /wp-content/mu-plugins/ folder.

    add_filter('woo_sl/default_expire/renew_price', 'woosl_apply_renew_discount', 10, 2 );
    /**
     * Apply a renew discount based on license expire / expired timestamps and a discount rules array.
     *
     * @param float $renew_price
     * @param int   $order_item_id
     * @param array $discount_rules Optional. If not provided the default rules (from your spec) are used.
     * @return float Discounted price (rounded to 2 decimals). If no discount applies returns the original price.
     */
    function woosl_apply_renew_discount( $renew_price, $order_item_id, $discount_rules = null ) 
        {
            // default rules (PHP array syntax)
            if ( $discount_rules === null ) 
                {
                    $discount_rules = [
                                            'before-expire' => [
                                                '30-6' => 40,  // between 6 and 30 days before expiry => 40%
                                                '5-0'  => 35,   // 0 to 5 days before expiry => 35%
                                            ],
                                            'after-expire'  => [
                                                '0-14'   => 30,  // expired 0 to 14 days => 30%
                                                '15-29'  => 25,  // expired 15 to 30 days => 25%
                                                '30-180' => 20,  // expired 31 to 180 days => 20%
                                                '181-'   => 10,  // expired 181 days or more => 10%
                                            ],
                                        ];
                }

            // Fetch timestamps from order item meta (as per your original code)
            $license_expire_at  = WOO_SL_functions::get_order_item_meta( $order_item_id, '_woo_sl_licensing_expire_at',  TRUE );
            $license_expired_at = WOO_SL_functions::get_order_item_meta( $order_item_id, '_woo_sl_licensing_expired_at',  TRUE );

            $now = time();

            // normalize timestamps to integers (0 if not numeric)
            $expire_ts  = is_numeric( $license_expire_at ) ? (int) $license_expire_at : 0;
            $expired_ts = is_numeric( $license_expired_at ) ? (int) $license_expired_at : 0;

            // helper to find matching discount percent from a rules array for a given days value
            $find_discount_for_days = function( array $rules, $days ) {
                // iterate rules in array order (preserves user's ordering)
                foreach ( $rules as $range => $pct ) 
                    {
                        // parse "A-B", "A-" or "-B" formats
                        $parts = explode( '-', $range, 2 );
                        $a = isset( $parts[0] ) && $parts[0] !== '' ? (int) $parts[0] : null;
                        $b = isset( $parts[1] ) && $parts[1] !== '' ? (int) $parts[1] : null;

                        // If both are null — skip invalid rule
                        if ( $a === null && $b === null ) {
                            continue;
                        }

                        // Determine min and max for inclusive comparison
                        if ( $a === null ) {
                            $min = PHP_INT_MIN;
                            $max = $b;
                        } elseif ( $b === null ) {
                            $min = $a;
                            $max = PHP_INT_MAX;
                        } else {
                            // handle reversed ranges like "30-6" by normalizing min/max
                            $min = min( $a, $b );
                            $max = max( $a, $b );
                        }

                        if ( $days >= $min && $days <= $max ) {
                            return (float) $pct;
                        }
                    }

                return 0.0; // no match
            };

            $DAY = 86400;

            $applied_pct = 0.0;

            if ( $expire_ts > 0 ) 
                {
                    if ( $expire_ts > $now ) 
                        {
                            // license not yet expired -> days until expiry
                            // Use ceil so partial day counts as a full day remaining (you can change to floor if you prefer)
                            $days_to_expire = (int) ceil( ( $expire_ts - $now ) / $DAY );

                            // find discount in before-expire rules
                            if ( ! empty( $discount_rules['before-expire'] ) && is_array( $discount_rules['before-expire'] ) ) {
                                $applied_pct = $find_discount_for_days( $discount_rules['before-expire'], $days_to_expire );
                            }
                        } 
                    else 
                        {
                            // expired already -> days since expiry
                            // Use floor so only completed days count as "days since"
                            $days_since_expiry = (int) floor( ( $now - $expire_ts ) / $DAY );

                            if ( ! empty( $discount_rules['after-expire'] ) && is_array( $discount_rules['after-expire'] ) ) {
                                $applied_pct = $find_discount_for_days( $discount_rules['after-expire'], $days_since_expiry );
                            }
                        }
                } 
            elseif ( $expired_ts > 0 ) {
                // no expire timestamp, rely on expired timestamp (assumed in the past)
                $days_since_expiry = (int) floor( ( $now - $expired_ts ) / $DAY );

                if ( ! empty( $discount_rules['after-expire'] ) && is_array( $discount_rules['after-expire'] ) ) {
                    $applied_pct = $find_discount_for_days( $discount_rules['after-expire'], $days_since_expiry );
                }
            } else {
                // no timestamps at all -> no discount
                $applied_pct = 0.0;
            }

            // Ensure renew price numeric
            $renew_price = (float) $renew_price;

            if ( $applied_pct > 0 ) {
                $discounted_price = round( $renew_price * ( 1 - ( $applied_pct / 100.0 ) ), 2 );
            } else {
                $discounted_price = round( $renew_price, 2 );
            }


            return $discounted_price;
        }

Benefits

• Higher renewal conversion — Timely discounts reduce friction for customers on the fence and increase the likelihood of on-time renewals.
• Targeted reactivation — Automated post-expiry discounts (e.g., first 14 days) are a low-touch way to win back lapsed customers.
• Flexible marketing — Define different discount intensities for “about to expire” vs. “long expired” to match business strategy.
• Reduced churn & predictable revenue — Offering graduated discounts keeps customers on board and smooths renewal cycles.
• Automation & consistency — Centralized rules mean every license follows the same logic — no manual price edits.
• A/B and analytics-friendly — Because rules are data-driven, you can test different percentages and ranges and measure lift.

License renewals are a critical moment in the customer lifecycle. When a product is close to expiring—or has already expired—users are more likely to hesitate, delay, or abandon renewal altogether. Instead of relying solely on reminder emails or manual promotions, WP Software License allows you to turn these moments into opportunities by applying automatic, expiration-based discount pricing.

With the Implement Discount Pricing for Expiring Products feature, you can dynamically adjust renewal prices based on how many days remain before a license expires or how long it has been inactive. By leveraging the built-in expiration functionality and a simple programmatic filter, you gain full control over renewal incentives—rewarding early renewals, encouraging quick reactivation, and reducing long-term churn without ongoing manual effort.

This approach not only improves the renewal experience for customers but also creates a predictable, data-driven strategy for maximizing lifetime value. In the sections below, you’ll learn how expiration-based discounting works, how to define flexible discount rules, and why this feature is a powerful addition to any license-based business.

The post Implement Discount Pricing for Expiring Products appeared first on WP Software License for WooCommerce.

What the integration does — in plain terms

When a customer purchases a subscription product, WPSubscription manages the billing (recurring charges, trials, renewals) while WP Software License automatically issues and manages the corresponding license keys. If a subscription expires or is canceled, the license status is updated accordingly — no manual intervention required. That means active subscribers keep working software and access to updates; expired accounts lose license access until they renew.

Why this combo helps your business

• Predictable recurring revenue — WPSubscription handles automated renewals, flexible billing cycles, free trials, and gateway integrations so payments stay on autopilot. This simplifies cashflow forecasting and growth planning.
• Automated license lifecycle — WP Software License issues keys on purchase, supports pre-saved or dynamically generated keys, and updates licenses automatically when subscription status changes. That removes a major source of manual work and support overhead.
• Better customer experience — customers get keys in email and in their My Account area, can manage licenses themselves, and receive secure automatic updates for downloadable products — all of which reduces friction and increases satisfaction.
• Flexible product support — WP Software License supports any WooCommerce product type (simple, variable, grouped, and subscriptions), so you can license everything from a single downloadable plugin to tiered plans with multiple seats.

Key technical strengths

• License management + API: WP Software License includes a JSON API and prebuilt examples so your software can authenticate, activate, and check updates programmatically. That makes secure update distribution and activation checks straightforward.
• Multiple gateways & billing features: WPSubscription supports major gateways and subscription features — automated renewals, trials, sign-up fees, and easy plan management — so you can design pricing that fits your customers.
• Variable subscriptions & multiple items per order: Both plugins support complex product types and cart scenarios (variable subscriptions, multiple subscriptions in one order), giving you flexibility to sell seat-based or tiered licensing.

Use cases that get immediate wins

• SaaS-style WordPress plugins or themes sold as a subscription with licensed updates and support.
• Desktop or mobile apps that require license activation tied to a recurring payment.
• Physical products that include a software component (predefined keys shipped with the product) and recurring maintenance plans.

Quick setup notes

1. Install and activate WPSoftwareLicense and WPSubscription on your WooCommerce site.
2. Create subscription products (simple or variable) in WooCommerce. Configure billing cycles and gateway settings in WPSubscription.
3. Configure licensing data for the product inside WP Software License so that when a subscription is completed, a license is issued automatically. WP Software License will update license status on cancellations/expirations.

Combining WP Software License with WPSubscription turns a WooCommerce store into a full-featured subscription + licensing platform: reliable recurring billing, automated license issuance, secure updates, and self-service license management. For businesses selling licensed software or maintenance plans, this integration pays back quickly in reduced support costs and improved customer retention.

The post WP Software License and WPSubscription integration – seamless licensing for recurring products appeared first on WP Software License for WooCommerce.

Key Features and Benefits

• Seamless Integration: WP Software License works effortlessly with WooCommerce Subscriptions, supporting both Simple and Variable Subscriptions.
• Automated Workflow: The plugin automatically manages the licensing workflow. When a subscription expires or is canceled, the associated licenses are updated accordingly.
• Easy Setup: Setting up the WP Software License with WooCommerce Subscriptions is straightforward, providing a user-friendly interface and comprehensive options for customization.

Setting Up WP Software License with WooCommerce Subscriptions

1. Install and Activate Plugins:
   • Ensure both WP Software License and WooCommerce Subscriptions plugins are installed and activated on your WooCommerce store.
2. Create a Subscription Producto or use any already existing:
   • Navigate to the WooCommerce Products page and create a new product.
   • Select “Simple subscription” or “Variable subscription” from the Product Data dropdown menu.
   • Configure the subscription details such as price, billing interval, and expiration settings.
3. Configure License Settings:
   • Fill in the Licensing Data as to described in the article.
4. Integrate License with Subscription:
   • When a subscription is purchased, the license will be issued automatically.
   • If the subscription is canceled or expires, the license status will automatically update to reflect the change.

Streamlined Subscription Management

The integration of WP Software License with WooCommerce Subscriptions offers a powerful and flexible tool for managing recurring payments and licenses. This integration is ideal for businesses looking to streamline the process of providing licenses for both virtual and physical products on a subscription basis.

One of the standout features of this integration is the automated workflow that ensures licensing changes are automatically reflected based on the subscription status. When a subscription is active, the corresponding license remains valid. If the subscription expires or is canceled, the license status is updated accordingly, removing the need for manual intervention. This automation provides a seamless experience for both store owners and customers, ensuring that licenses are always up-to-date with the subscription’s status.

Additionally, the WP Software License plugin offers versatile options for license key management. License keys can either be generated dynamically or pre-saved for distribution. This flexibility allows businesses to tailor their licensing approach to meet specific needs, whether they are distributing software, digital content, or physical products that require a license.

For example, software companies can use dynamically generated keys to provide unique licenses for each subscriber, ensuring security and personalization. On the other hand, businesses selling physical products that include a software component can pre-save license keys, which are then provided to customers upon purchase and subscription activation.

Overall, the integration of WP Software License with WooCommerce Subscriptions enhances the capability of any WooCommerce store, making it an essential tool for efficiently managing recurring billing and licensing for a wide range of products and services. For more detailed setup instructions and customization options, visit the WP Software License Documentation.

The post Compatibility with WooCommerce Subscriptions plugin appeared first on WP Software License for WooCommerce.

The process of licensing, delivering, and protecting software can be complex. However, by utilizing licensing technologies such as our WP Software License for WooCommerce, developers can streamline the process of protecting their software and ensuring that it is delivered to customers securely. License keys are one of the most popular ways of achieving this.

License keys are unique codes that are used to activate a software license. They can be generated automatically and are typically sent to customers via email or provided through a web portal. When the license key is entered into the software, it unlocks access to the full version of the software, and the user is free to use it.

One of the benefits of using license keys is that they allow developers to control software updates and support. With a license key, developers can track which version of the software the user is running and ensure that updates are delivered only to those who are entitled to receive them. This not only ensures that users have access to the latest features but also helps to prevent unauthorized use of the software.

WP Software License for WooCommerce is also a popular choice for subscription-based models. By licensing their software on a subscription basis, developers can ensure that they receive a regular income from their customers. Subscriptions can be customized to suit the needs of individual users, and developers can offer different pricing tiers and subscription durations.

Another advantage of using software licensing is the ability to track active licenses and deployments. Developers can use licensing technologies to monitor how many licenses are being used and where they are being used. This information can help developers to identify areas where their software is in high demand and to optimize their pricing and licensing models accordingly.

In summary, software licensing and the use of license keys provide developers with a reliable way of controlling and managing the distribution of their software. By utilizing licensing technologies, developers can protect their intellectual property, ensure that software updates and support are delivered securely, and monitor their software usage and deployments.

The post Why use software licensing for your Product appeared first on WP Software License for WooCommerce.

Debugging API interaction is simple, calling the arguments using raw URL, returns the actual API response that the customer application receives. When this is not possible, a log can be created on the API machine, which will record all calls and responses for a specific license key ( customer ) or a list of keys. To achieve this feature a simple code can be used. This should be placed within /wp-content/mu-plugins/woosl-custom.php The name should be preserved as woosl-custom.php to ensure the system loads the code when using API Cache.

    add_filter( 'WOOSL/API_call/response', '__woosl_api_call_response__log', 10, 2 );
    function __woosl_api_call_response__log ( $response, $args )
        {
            
            $log_keys   =   array (
                                    '57285638-4a95bb52-187l7ddf'  
                                    );
               
            if ( ! isset ( $_REQUEST['licence_key'] )     ||    ! in_array ( $_REQUEST['licence_key'], $log_keys ) )
                return $response;
                
            
            $log    =    "--------------------------\n";
            $log    .=   "A new call at ". date("Y-m-d H:i:s") ."\n";
            $log    .=   "Call GET request " . print_r( $_GET, TRUE ) ."\n";
            $log    .=   "Call POST request " . print_r( $_POST, TRUE ) ."\n";
            $log    .=   "Response is " . print_r( $response, TRUE ) ."\n";
            
            //creates the log on WordPress root
            $Logfile = fopen("WooSL_log.txt", "a");
            fwrite( $Logfile, $log );
            fclose( $Logfile );

            return $response;    
        }

The post Create logs on API calls for specific customers license keys appeared first on WP Software License for WooCommerce.

Depending on the active plugins on your side, the above options becomes selectable.

For easy management and track of all existing customers and their license keys, the plugin implements a dedicated interface as Licenses. Within the area, each of the keys appears along with its own appropriate details:

As default, the following columns are available for the table:

• Order ID
• Key / Licence Status
• Product
• Customer
• Licence Group
• Licence Key
• Expire
• Key Date
• Active Domain
• Actions

The columns can change through the Screen Option or programmatically using a custom filter as details on Add custom columns to dashboard Licences interface.

Using the top header options, the License list becomes filterable. This helps to easily visualize the required chunk of licenses with a specific status or attribute:

The list is dynamically populated, depending on the found licenses types within the system at a given point. The default fields are:

• All – list all license keys.
• Active – all licenses with active status.
• Inactive – show items with inactive statuses.
• Expired – outputs the expired licenses, for which the expiration data has outdated and no extend occurred.
• Not Acticated – all license keys not yet activated ( if using the Start the Expire on activate option ).
• Cancelled – list items with cancelled status.
• Active Orders( Using Expire ) – show active orders using expire / subscription

The Active Orders( Using Expire ) filter, outputs all Active Orders with licensing set-up, using either internal Expire functionality or Subscription for WooCommerce Subscriptions / YITH WooCommerce Subscription. This is a straightforward function to facilitate the visualisation of all non-expired, on-going subscription types licenses.

The post Manage the Expire / Subscription licenses appeared first on WP Software License for WooCommerce.

As soon as you start to sell your products via the WooCommerce store, you may start worrying that someone will copy your products or just change a few things then sell them as their own. WP Software License is a plugin that helps you manage product licensing, software update, maintenance, and code protection all in one place. It helps to calculate the license renewal date, alert the user when the license is about to expire, can help you avoid copyright infringement.

The YITH WooCommerce Subscription plugin is a WordPress plugin that allows you to sell products efficiently. It’s perfect for people who are not experts in WooCommerce but want to have a successful online store. You no longer need to create an account, select the subscriptions pricing plan, or upgrade manually. The YITH WooCommerce Subscription plugin does everything for you!

Selling subscriptions for a product is the best way for a self-sustaining business model. This approach ensures the availability of required resources for the development team to continue code improvements and support over the product. The WP Software License integrates seamlessly with YITH WooCommerce Subscription.

The subscription plugin support any product type, it can be a Simple Product or a Variable. Creating the relationship on the subscribed product and the license is self explanatory to achieve through the product page:

The existing subscriptions are automatically managed by the plugin, there is no maintenance work required whatsoever.

The post Sell licensed software using YITH WooCommerce Subscription appeared first on WP Software License for WooCommerce.

There are situations when the key is required to be retrieved from a 3rd API, at the order completed, which will be delivered to customer. This is easy to achieve through a programmable filer. The following code does just that:

    add_action('woocommerce_order_item_meta_end', 'retrieve_custom_license_keys', 1, 3);
    function retrieve_custom_license_keys( $item_id, $item, $order )
        {
            global $wpdb;
            
            $order_data     = new WC_Order( $order->get_ID() );
     
            $order_products =   $order_data->get_items();
     
            $license_active_for_status  =   array ( 'completed' );
            
            $time           = date("Y-m-d H:i:s", time());
            
            //iterate all order items and check for any licence
            foreach( $order_products    as  $order_item_id  =>  $order_data )
                {
                    if ( ! WOO_SL_functions::is_order_item_licensed ( $order->get_ID() , $order_item_id ) )
                        continue;
                    
                    if( in_array ( $order->get_status(), $license_active_for_status ) ===  FALSE )
                        continue;
                    
                    $_woo_sl    =   WOO_SL_functions::get_order_item_meta($order_item_id,  '_woo_sl',  TRUE);
                    if(!    is_array($_woo_sl))
                        continue;
                    
                    foreach($_woo_sl['group_title']    as  $_group_id    =>  $_group_title)
                        {
                            $license_keys   =   (array)WOO_SL_functions::get_order_product_generated_keys( $order->get_ID(), $order_item_id, $_group_id );
                            if(count($license_keys) > 0)
                                continue;
                            
                            
                            //retrieve the licence key from the 3rd API
                            $new_licence_key    =   '.....';
                            
                            
                             
                            //insert the key on database
                            $mysql_query    =   "INSERT INTO ". $wpdb->prefix . "woocommerce_software_licence  ( `order_id`, `order_item_id`, `group_id`, `licence`, `created` ) 
                                                        VALUES ( '". $order->get_ID() ."', '". $order_item_id ."', '". $_group_id ."', '".  $new_licence_key  ."', '". $time ."')";
                            $result         =   $wpdb->get_results( $mysql_query );
                        }
                                           
                }
     
        }

The above code should be place inside theme functions.php file or a custom plugin.

The post Add a custom licence key on order completed appeared first on WP Software License for WooCommerce.

• Order ID
• Key / Licence Status
• Product
• Customer
• Licence Group
• Licence Key
• Expire
• Key Date
• Active Domain
• Actions

Through filters, custom columns can be added to the interface. The following example display the renew price for a licence, if apply:

    add_filter('manage_woocommerce_page_sl-licences_columns',    'manage_woocommerce_page_sl_licences_columns');
    function manage_woocommerce_page_sl_licences_columns( $columns )
        {
            
            $columns['renew_price']  =   'Renew Price';
               
            return $columns;   
        }
        
    add_action ('manage_woocommerce_page_sl-licences_column_renew_price', 'manage_woocommerce_page_sl_licences_column_renew_price');
    function manage_woocommerce_page_sl_licences_column_renew_price( $item )
        {
            global $WOO_SL;
            
            $order_item_woo_sl          =   $WOO_SL->functions->get_order_item_meta( $item->order_item_id, '_woo_sl');
            //use the first group
            reset($order_item_woo_sl['group_title']);
            $use_key    =   key( $order_item_woo_sl['group_title'] );  
            
            if  ( $order_item_woo_sl['product_use_expire'][$use_key] != 'yes' )
                return;
                
            echo wc_price ( $order_item_woo_sl['product_expire_renew_price'][$use_key] ) ;
            
        }

The post Add custom columns to dashboard Licences interface appeared first on WP Software License for WooCommerce.

The next code example add the licensed product version nwxt to the Product name within the archive interface:

    add_filter( 'manage_product_posts_custom_column', 'admin_product_title_version', 99, 2 );
    function admin_product_title_version( $column, $postid ) 
        {
            if ( 'name' === $column ) 
                {
                    $product = wc_get_product( $postid );
                    if ( 'yes' === $product->get_meta('_sl_enabled') ) 
                        {
                            printf(
                                '
<strong>v %s</strong>',
                                $product->get_meta('_sl_new_version')
                            );
                        }
                }
        }

The above code can be included within theme functions.php, within a custom plugin or mu-plugins folder. The expected results appear like this:

Other licensing fields can be used too, as follow:

• _sl_software_title
• _sl_software_unique_title
• _sl_plugin_url
• _sl_product_expire_units
• _sl_product_expire_time
• _sl_version_required
• _sl_tested_up_to
• _sl_last_updated
• _sl_update_nottice

The post Add additional licence details on Products archive page appeared first on WP Software License for WooCommerce.