Standard Setup (Free)

The core framework is available on the WordPress.org repository.

• Navigate to Plugins -> Add New.
• Search for CartLane.
• Install and activate the plugin.

WP-CLI

# 1. Install base plugin
wp plugin install cartlane --activate

# 2. Upload and activate Pro
wp plugin install ./cartlane-pro.zip --activate

Global Settings

Once installed, navigate to CartLane -> Settings in your WordPress dashboard. Here you can configure:

• Brand Colors: Sync your brand primary and secondary colors across all checkouts and carts.
• Typography: Inherit your theme font stack or define custom Google Fonts.
• HPOS Sync: Monitor high-performance order storage sync status directly from the panel.

Advanced Developer Hooks

Need to programmatically override settings for specific user roles or environments? CartLane exposes robust PHP filters for all configuration payloads.

// Example: Force dark mode side cart for wholesale customers
add_filter( 'cartlane_get_global_settings', function( $settings ) {
    if ( current_user_can( 'wholesale_buyer' ) ) {
        $settings['theme']['mode'] = 'dark';
        $settings['features']['skip_cart'] = true;
    }
    return $settings;
});

Triggering the Cart

By default, CartLane automatically binds to your theme native Add to Cart buttons and cart menu icons. You can manually trigger the side cart using custom CSS classes.

• .cartlane-open-cart - Add this class to any link or button to open the side cart on click.
• .cartlane-toggle-cart - Toggles the side cart visibility dynamically.

JavaScript Custom Events

CartLane dispatches custom DOM events that you can listen to in your theme or custom scripts.

// Listen for when the side cart is fully opened
document.addEventListener( 'cartlane:cart_opened', function( e ) {
    console.log( 'Cart opened! Current total:', e.detail.cartTotal );
});

// Listen for an item being added to the cart
document.addEventListener( 'cartlane:item_added', function( e ) {
    console.log( 'Added product ID:', e.detail.productId );
});

Field Editor

CartLane provides a built-in field editor to hide, require, or rename checkout fields without writing custom PHP.

• Hide Company Name: Perfect for B2C stores.
• Hide Phone Number: Only ask for what you need to ship.
• Address workflow: Keep shipping and billing fields focused on the details your store actually needs.

Trust Signals

CartLane automatically injects security badges and trust signals around the Place Order button to reassure buyers right before they pay.

Global Placement

CartLane leverages React and Zustand for state management, meaning Order Bumps are not restricted to just the checkout page. You can dynamically render them inside the AJAX Side Cart as well.

Live Cart Tracking

CartLane uses early-capture technology. As soon as a user enters an email address in the checkout field or logs into their account, their cart state is synchronized in the background.

// Filter the checkout capture delay (default is 15 minutes)
add_filter( 'cartlane_abandoned_cart_cutoff_time', function( $minutes ) {
    return 30;
});

Core Concepts

A CartLane Funnel is built using nodes connected via conditional paths.

• Trigger Nodes: What starts the funnel, such as Global Checkout or a specific product purchase.
• Offer Nodes: The pages shown to the user, such as Upsell or Downsell.
• Conditionals: Logic gates that route the user based on previous actions.

REST API Architecture

All funnel definitions are serialized and stored efficiently, and execution happens seamlessly via the REST API during checkout.

// Filter funnel execution logic programmatically
add_filter( 'cartlane_pro_funnel_should_execute', function( $should_execute, $funnel_id, $order ) {
    if ( $order->get_total() > 5000 ) {
        return false;
    }
    return $should_execute;
}, 10, 3 );

How It Works

Traffic is distributed across variants using a secure tracking cookie. The backend can record configured events and variant performance data for CartLane reports.

Developer API

Hook into the variant assignment process to integrate external analytics.

// Hook into variant assignment
add_action( 'cartlane_pro_assigned_ab_variant', function( $experiment_id, $variant_id, $session_id ) {
    External_Tracker::log_experiment( [
        'experiment' => $experiment_id,
        'variant'    => $variant_id,
        'session'    => $session_id,
        'timestamp'  => time(),
    ] );
}, 10, 3 );

Supported Rule Types

CartLane Pro supports a wide array of condition-based pricing architectures:

• Volume Discounts: Buy 5 to 9 items get 10% off; buy 10+ get 20% off.
• BOGO: Buy 2 t-shirts, get 1 cap free.
• Role-Based Pricing: Exclusive wholesale catalogs for logged-in B2B users.

Performance First

Traditional pricing plugins often crash WooCommerce due to recursive cart recalculations. CartLane rule engine evaluates pricing trees in memory and caches the outcome.

Programmatic Overrides

Developers can inject completely custom algorithms into the pricing pipeline using the provided filter hooks.

// Filter the final price of a cart item
add_filter( 'cartlane_pro_calculate_item_price', function( $price, $cart_item, $rule_context ) {
    if ( is_user_logged_in() && check_is_user_birthday( get_current_user_id() ) ) {
        return max( 0, $price - 5.00 );
    }
    return $price;
}, 10, 3 );

Event Tracking

Through the Event_Tracker module, CartLane can record module-specific events locally without requiring third-party tracking scripts.

• Cart events: drawer opened, item added, coupon applied, checkout clicked.
• Order bump events: bump viewed, accepted, removed, and purchased.
• Funnel events: step viewed, offer accepted, offer skipped, and funnel completed.
• Recovery events: cart captured, email queued, email sent, and recovered checkout linked.

Report Views

Store owners can review CartLane reports by module and date range so operational decisions stay tied to plugin activity instead of mixed marketing data.

• Revenue Overview: totals from CartLane-assisted bumps, funnels, and recovery workflows.
• Funnel Steps: step-by-step drop-off and accept/skip activity for configured funnels.
• Recovery Queue: captured carts, email status, and recovered checkout references.
• Experiment View: variant assignment and configured event performance for A/B tests.

Developer Hooks

Developers can mirror selected CartLane events into their own reporting layer without editing plugin files.

add_action( 'cartlane_analytics_event_recorded', function( $event_name, $payload ) {
    if ( 'order_bump_accepted' !== $event_name ) {
        return;
    }

    // Send a sanitized copy to your internal reporting service.
    my_store_log_cartlane_event( [
        'event'    => sanitize_key( $event_name ),
        'order_id' => absint( $payload['order_id'] ?? 0 ),
        'bump_id'  => absint( $payload['bump_id'] ?? 0 ),
    ] );
}, 10, 2 );

Supported Gateways

• Stripe: Adapter-readiness guidance for WooCommerce Stripe gateway integrations.
• PayPal: Adapter-readiness guidance for PayPal gateway workflows that support tokenized follow-up charges.
• WooPayments: Adapter-readiness guidance for WooPayments-based checkout flows.

Custom Gateway Integration

If you are using a local or custom payment gateway, you can register a new adapter using the RealUpsellGatewayAdapterRegistry.

add_action( 'cartlane_register_gateway_adapters', function( $registry ) {
    // Requires implementing RealUpsellGatewayAdapterInterface.
    $registry->register( new My_Custom_Gateway_Adapter() );
});

Cart Endpoints

Authentication (Nonce)

For logged-in users or sessions managed by WooCommerce, include the WordPress nonce in the headers of your requests.

fetch( '/wp-json/cartlane/v1/cart/add', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-WP-Nonce': cartlane_data.nonce
    },
    body: JSON.stringify( { product_id: 123, quantity: 1 } )
} )
.then( res => res.json() )
.then( data => console.log( data ) );

Data Retrieval Methods

If you are writing custom integrations, always use WooCommerce CRUD objects to interact with orders created through CartLane.

// Correct way to get CartLane metadata from an HPOS order
$order = wc_get_order( $order_id );
$funnel_data = $order->get_meta( '_cartlane_funnel_data' );

// NEVER DO THIS (Breaks in HPOS):
// $funnel_data = get_post_meta( $order_id, '_cartlane_funnel_data', true );

Analytics & HPOS

Our internal Analytics engine uses custom lightweight tables joined correctly with WooCommerce order tables using abstract DB query layers. No direct table hardcoding exists.

General Questions

CartLane is built for WooCommerce stores that want faster cart interactions, cleaner checkout controls, order bump workflows, and Pro funnel features.

• Does CartLane replace WooCommerce? No. CartLane extends WooCommerce cart and checkout workflows.
• Can I use only the side cart? Yes. Modules can be configured independently where the plugin settings expose module controls.
• Does CartLane require a page builder? No. CartLane works through plugin modules, WordPress hooks, and WooCommerce integration points.

Free vs Pro

The free plugin focuses on core cart and checkout infrastructure. Pro unlocks advanced conversion features documented in the Advanced section.

• Free: AJAX Side Cart, base checkout controls, and developer extension points.
• Pro: Funnel Builder, A/B Testing, Dynamic Pricing, Analytics, and Payment Gateway adapters.
• License-gated features remain disabled until a valid Pro license is activated.

Compatibility

CartLane is designed for modern WooCommerce environments using current WordPress standards, REST endpoints, nonces, and HPOS-safe order access.

• PHP 8.0+ is recommended for production stores.
• WooCommerce HPOS is supported through WooCommerce CRUD APIs.
• Theme conflicts are usually resolved by checking cart trigger selectors and checkout template overrides.

Cart Issues

If the side cart does not open, confirm the module is enabled and your theme buttons are still using WooCommerce add-to-cart behavior.

• Clear page cache and object cache after changing CartLane module settings.
• Check that custom buttons include a supported CartLane trigger class or WooCommerce add-to-cart attributes.
• Disable script optimization temporarily if a performance plugin delays CartLane frontend assets.

Checkout Issues

Checkout conflicts usually come from theme template overrides, payment gateway scripts, or custom snippets changing WooCommerce fields late in the request.

• Test with a default WooCommerce-compatible theme to isolate template overrides.
• Confirm active payment gateways render correctly on the default WooCommerce checkout.
• Review custom snippets that modify checkout fields, totals, fees, or payment fragments.

Debug Checklist

When reporting an issue, capture the module state and environment first. This avoids guessing and shortens support turnaround.

1. WordPress version
2. WooCommerce version
3. CartLane version
4. Active theme name
5. Enabled CartLane modules
6. Browser console errors
7. Steps to reproduce

Safe Updates

For production WooCommerce stores, update during low-traffic windows and test checkout, cart, and payment flows immediately after the update.

• Back up the database before updating revenue-critical checkout tools.
• Update WooCommerce-compatible payment gateways before testing one-click upsell flows.
• Purge cache after updating CartLane assets or checkout configuration.

Before Contacting Support

Run through the troubleshooting checklist first and confirm the issue still occurs with CartLane enabled and relevant modules configured.

• Confirm the issue is reproducible on a clean browser session.
• Check browser console errors on the affected cart or checkout page.
• Test with cache/minification disabled if assets appear stale.

What To Include

Support requests should include exact steps, environment details, and the CartLane module involved.

• CartLane version, WordPress version, WooCommerce version, PHP version.
• Active theme and relevant checkout/payment/cart plugins.
• Screenshots or a short screen recording of the issue.
• Temporary admin access only when requested through the official support workflow.