Magento 2.2.4: Auto-Removing Items From Cart After 24 Hours

Jan 16, 2026 by Editorial Team 60 views

Hey guys! Ever wondered how to automatically clear those abandoned carts in Magento 2.2.4? It's a common issue, right? Customers add items, get distracted, and leave the cart full. This can lead to cluttered carts and potential inventory issues. This guide breaks down how to automatically remove items from the cart after 24 hours, addressing both guest and logged-in users, as well as scenarios where a customer cancels or returns from the payment page. We'll dive into the code and explain the logic behind it, making it easier for you to implement this essential feature. This is all about improving the user experience and optimizing your store's performance. So, let's get started and make your Magento store a little bit more efficient!

Understanding the Need for Auto Cart Removal in Magento 2.2.4

Okay, so why bother with automatically removing items from the cart? Well, there are several solid reasons. First, reducing cart abandonment is a huge one. Abandoned carts represent lost sales, and by clearing them out after a certain period, you encourage customers to either complete their purchase or start fresh. Second, it helps with inventory management. If a product is sitting in a cart for a long time, it's effectively unavailable to other customers, potentially leading to missed sales. Third, it contributes to a cleaner and more organized storefront. Imagine having tons of old items in carts – it can be a messy experience for customers. Finally, it's about improving the user experience. No one wants to see old, outdated items lingering in their cart. So, implementing this feature is a win-win for both the business and the customer.

The Problem with Abandoned Carts

Abandoned carts are a real pain. They represent a significant loss of potential revenue for e-commerce stores. The reasons for cart abandonment are varied, from unexpected shipping costs to website glitches. However, many customers simply get distracted or decide to postpone their purchase. Without a system in place to manage these carts, your store can quickly accumulate a backlog of abandoned items, leading to various issues. Think about it: customers might add items, browse for a while, and then leave. If those items stay in the cart indefinitely, it creates a less-than-ideal user experience and can cause problems with inventory. Automating the removal process is a smart move that helps reclaim some of those lost sales and keeps your store running smoothly. We're talking about reducing the clutter, optimizing inventory, and ultimately, boosting your bottom line. It's not just about removing items; it's about making your store more efficient and user-friendly. By implementing this feature, you're taking a proactive step toward a better shopping experience.

Benefits of Implementing Auto Cart Removal

Implementing auto cart removal offers several key benefits. First and foremost is improved inventory management. By clearing out old cart items, you free up inventory, preventing potential overselling issues. Second, it enhances the user experience. A clean, up-to-date cart feels much more welcoming than one cluttered with outdated items. Third, it can potentially boost sales. If a customer comes back after a day or so and finds their cart empty, they might be more inclined to browse and add new items, rather than being reminded of an abandoned purchase. Fourth, it reduces the load on your server. Fewer stale cart sessions mean less data processing, which can improve your site's performance. Finally, and perhaps most importantly, it can lead to increased conversion rates. When customers return and see a fresh start, they might be more likely to complete a new purchase. The goal is to make the shopping process as smooth and appealing as possible, and auto cart removal is a step in that direction. This feature isn't just about cleaning up the database; it's about making your store more efficient, user-friendly, and profitable.

Setting Up Auto Cart Removal: Code and Implementation

Alright, let's get into the nitty-gritty and see how we can implement this feature in your Magento 2.2.4 store. We'll be working with a few key components: a custom module, a cron job, and some code to handle the actual cart cleanup. Don't worry, it's not as complex as it sounds. We'll break it down step by step.

Creating a Custom Module

First, you'll need to create a custom module. This is where your code will live. Create the following directory structure within your Magento installation:

app/code/[YourVendor]/CartCleanup

Replace [YourVendor] with your vendor name (e.g., MyCompany).

Within this directory, create the necessary files:

etc/module.xml: This file defines your module.

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
    <module name="[YourVendor]_CartCleanup" setup_version="1.0.0"/>
</config>

Remember to replace [YourVendor] with your vendor name.

registration.php: This file registers your module.
```
<?php

use Magentoramework
```

egistration egister;

egister(

egister::MODULE, '[YourVendor]_CartCleanup', DIR ); ```

Again, replace `[YourVendor]`.

etc/crontab.xml: This file defines the cron job that will trigger the cart cleanup.

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Cron/etc/crontab.xsd">
    <group id="default">
        <job name="[yourvendor]_cartcleanup_removeoldcarts" instance="[YourVendor]\CartCleanup\Model\Cleanup" method="execute">
            <schedule>0 0 * * *</schedule>
        </job>
    </group>
</config>

Replace [yourvendor] with your vendor name. The <schedule> tag defines when the cron job runs (in this case, every day at midnight).

Implementing the Cart Cleanup Logic

Now, let's create the actual cleanup logic. Create the Model/Cleanup.php file within your module:

<?php

namespace [YourVendor]\CartCleanup\Model;

use Magentoramework\Stdlib\DateTime\\	imezonetranslatorinterface;
use Magentoramework\Stdlib\\	imezonetranslator; 
use Magentoramework\Stdlib\\	imezone; 
use Magentoramework\Stdlib\\	ime; 
use Magentoramework\Stdlib\\	ime; 
use Magentoramework\\	ime; 
use Magentoramework\App\State; 

use Magentoramework\App\\
esourceconnection; 
use Magentoramework\\
esourceconnection; 
use Magentoramework\\
esourceconnection; 



class Cleanup
{

    protected $checkoutSession;
    protected $quoteCollectionFactory;
    protected $customerSession;
    protected $logger;
    protected $timeZone; 
    protected $resourceConnection;
    protected $state;



    public function __construct(
        \Magento\Checkout\Model\Session $checkoutSession,
        \Magento\Quote\Model\ResourceModel\Quote\CollectionFactory $quoteCollectionFactory,
        \Magento\Customer\Model\Session $customerSession,
        \Psr\Log\LoggerInterface $logger,
        \Magento\Framework\Stdlib\DateTime\TimezoneInterface $timeZone,
        \Magento\Framework\App\ResourceConnection $resourceConnection,
        State $state
    ) {
        $this->checkoutSession = $checkoutSession;
        $this->quoteCollectionFactory = $quoteCollectionFactory;
        $this->customerSession = $customerSession;
        $this->logger = $logger;
        $this->timeZone = $timeZone;
        $this->resourceConnection = $resourceConnection;
        $this->state = $state;

    }

    public function execute()
    {
        try {
            $this->state->emulatestore(0,function() {
            $connection = $this->resourceConnection->getConnection();
            $tableName = $this->resourceConnection->getTableName('quote');
            $select = $connection->select()->from($tableName)->where('updated_at <= ?', date('Y-m-d H:i:s', strtotime('-1 day')));
            $quotes = $connection->fetchAll($select);

            if (count($quotes) > 0) {
                foreach ($quotes as $quote) {
                    try {
                        $quoteId = $quote['entity_id'];
                        $connection->delete($tableName, ['entity_id = ?' => $quoteId]);
                        $this->logger->info(sprintf('Deleted quote with ID: %s', $quoteId));
                    } catch (\\\Exception $e) {
                        $this->logger->error(sprintf('Error deleting quote %s: %s', $quoteId, $e->getMessage()));
                    }
                }

                return true;
            }
        });
        } catch (\\\Exception $e) {
            $this->logger->error($e->getMessage());
            return false;
        }
    }
}

This code does the following:

Dependency Injection: It injects necessary dependencies like CheckoutSession, QuoteCollectionFactory, CustomerSession, and a logger. This is how Magento handles dependencies, making your code cleaner and more maintainable.
execute() Method: This is the core method that will be executed by the cron job.
Querying for Old Quotes: Fetches the quote table, and retrieves all the quotes that have been updated more than a day ago.
Quote Deletion: If old quotes are found, it iterates through them and deletes each one from the database using a database connection. It logs any errors that occur during the deletion process. Be very careful with database operations.
Logging: It logs important actions, like quote deletion and any errors that occur. Logging is crucial for debugging and monitoring your module's performance.

Running the Cron Job

After setting up your module and deploying your code, you need to run the cron job. Important: You must run the cron job using the command line.

Enable the Module: First, enable your module using the command line:

php bin/magento module:enable [YourVendor]_CartCleanup
php bin/magento setup:upgrade
php bin/magento setup:di:compile
php bin/magento cache:flush

Clear the cache to make sure your changes are reflected.

Run the Cron: You can manually run the cron jobs or wait for the automatic execution. Use this command:
```
php bin/magento cron:run
```
This command will execute all pending cron jobs, including your cart cleanup task.
Verify the Results: Check your logs (usually in var/log/system.log) to confirm that the cron job is running and deleting old carts. The logs will provide valuable information about what's happening behind the scenes, including any errors. If everything is working correctly, you should see messages indicating successful cart deletions.

Note: Make sure to test this in a staging environment before pushing it to production to avoid potential data loss. Always back up your database before making changes.

Handling Guest and Logged-in Users in Magento 2.2.4

The great thing about the code we wrote is that it handles both guest and logged-in users. The quote table in Magento stores all cart information, regardless of whether a user is logged in or not. The cron job we created queries the quote table for carts that haven't been updated in the last 24 hours. Because the cart data for both guest and logged-in users is stored in the same place, our code automatically applies to both user types. This unified approach simplifies the process and ensures that all abandoned carts, regardless of user status, are cleared out after the specified time.

Differences Between Guest and Logged-in Carts

While the underlying storage mechanism is the same, there are some differences in how guest and logged-in carts behave. Logged-in users have their carts associated with their customer accounts, allowing them to retrieve their carts across multiple sessions. Guest users, on the other hand, have their cart data tied to their session ID (stored in cookies). When the session expires or the cookie is cleared, their cart data is effectively lost, unless they come back within the 24-hour window.

Ensuring Universal Cart Cleanup

To ensure all carts, both guest and logged-in, are properly cleaned up, the cron job is designed to work independently of user sessions. It directly interacts with the database to find and remove outdated cart data. This approach is more reliable than relying on session-based logic, as it doesn't depend on user activity or cookie management. This method ensures all outdated carts are cleared, regardless of whether the user is logged in or not. The key is to run the cron job on a regular schedule, so your store keeps running efficiently and offers a great user experience.

Addressing Cart Removal on Payment Page Cancellation

Sometimes, customers navigate to the payment page but then cancel the process or are redirected back to the cart. We can also handle the auto removal of carts in these scenarios.

Detecting Payment Page Cancellations

To trigger cart removal upon payment page cancellation, you'll need to detect when a customer returns from the payment page without completing the order. Magento doesn't natively provide a straightforward way to identify this, so you need to look at a combination of events and conditions:

Observe the checkout_cart_save_after event: This event is dispatched after the cart is saved, which happens when the customer navigates back to the cart. You can observe this event and check if the quote has been updated recently (within the last 24 hours). If it hasn't, the customer may have abandoned the purchase. Create an observer to listen for this event. In your custom module, create a file etc/events.xml:
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
    <event name="checkout_cart_save_after">
        <observer name="[yourvendor]_cartcleanup_removeoncancel" instance="[YourVendor]\CartCleanup\Observer\RemoveAbandonedCart"/>
    </event>
</config>
```
Replace [yourvendor] with your vendor name.

Create the Observer: Create the observer class Observer/RemoveAbandonedCart.php:

<?php

namespace [YourVendor]\CartCleanup\Observer;

use Magento\Framework\Event\ObserverInterface;
use Magento\Framework\Event\Observer;
use Magento\Quote\Model\Quote;  // Import the Quote model
use Magento\Framework\Stdlib\DateTime\DateTime; // Import the DateTime class

class RemoveAbandonedCart implements ObserverInterface
{
    protected $quoteRepository;
    protected $dateTime;

    public function __construct(
        \Magento\Quote\Api\CartRepositoryInterface $quoteRepository,
        DateTime $dateTime
    ) {
        $this->quoteRepository = $quoteRepository;
        $this->dateTime = $dateTime;
    }

    public function execute(Observer $observer)
    {
        $quote = $observer->getEvent()->getQuote();
        if (!$quote instanceof Quote) {
            return;
        }

        $updatedAt = $quote->getUpdatedAt();
        $now = $this->dateTime->gmtTimestamp();
        $timeDiff = $now - strtotime($updatedAt);

        if ($timeDiff > 86400) { // 24 hours in seconds
            try {
                $this->quoteRepository->delete($quote);
            } catch (\\Exception $e) {
                // Log the error
                error_log('Error deleting quote: ' . $e->getMessage());
            }
        }
    }
}

This observer fetches the quote from the event and deletes it if it hasn't been updated within the last 24 hours.

Implement Logic in Observer: The key part here is to check the updated_at attribute of the quote. If the last update was more than 24 hours ago, you can safely assume the customer abandoned the cart and delete it. Handle exceptions with logging.

Testing Payment Page Cancellation

To test this, simulate a customer going through the checkout process, navigating to the payment page, and then returning to the cart. After the 24-hour window, verify that the cart is automatically removed.

Troubleshooting and Optimizing Auto Cart Removal

Implementing auto cart removal is usually a smooth process, but sometimes you may face some issues. Here's a quick guide to troubleshooting and optimizing your setup.

Common Problems and Solutions

Cron Jobs Not Running: Make sure your cron jobs are properly configured and running. Use the command php bin/magento cron:run and check the system logs (var/log/system.log) for any errors. If the cron isn't running, it means your cleanup tasks won't be triggered, so double-check your cron settings in crontab.xml and the server's cron configuration.
Incorrect Module Configuration: Verify that your module is enabled and correctly registered in module.xml and registration.php. Clear the Magento cache after making any changes. This ensures that Magento recognizes your module.
Permissions Issues: Make sure your Magento file system has the correct permissions. The web server user needs to have write access to the var and pub/static directories. Incorrect permissions can prevent the cron job from running or writing logs. Use chown and chmod commands on your server to fix permission problems.
Errors in the Code: Check your code for syntax errors and logic flaws. Review the logs for detailed error messages. Log, log, and log! Use logging extensively to track the execution of your cron job and observer. This will provide valuable clues if something is going wrong. Regularly check your log files.
Conflicts with Other Modules: Sometimes, other modules might interfere with your cleanup process. Check for any conflicts by temporarily disabling other modules and testing your cleanup functionality. If conflicts exist, review the code and try to resolve those conflicts. This involves figuring out what other modules are modifying the cart and how they interact with your code. Carefully examine the behavior of other modules to ensure they don’t interfere with your auto-removal process.

Optimizing Your Implementation

Schedule Optimization: Consider running the cron job during off-peak hours to avoid impacting your server's performance during busy times. This scheduling adjustment can improve your store's performance. Find the best time to run your cron jobs, such as midnight. Check the logs and see if your cron is running properly during that time.
Database Indexing: Ensure that your database tables, especially the quote table, have proper indexes. This can significantly speed up the query that identifies old carts. Proper indexing makes the query run much faster. Indexes speed up the retrieval of cart data, which can reduce the time it takes for your cron job to run and the overall load on your server. Make sure indexes are set for the updated_at column.
Testing and Monitoring: Regularly test your auto-removal process to ensure it's functioning correctly. Set up monitoring to track the number of carts being removed and any errors. This testing should be an ongoing part of your process. Run manual tests and monitor the logs to verify everything is working as expected. This proactive approach ensures your cart cleanup is consistently effective.
Logging: Implement detailed logging to track cart deletions and any errors. Logging is essential for monitoring and debugging. Logs help you catch issues early. Make sure to log every step, especially when deleting or updating the database. Proper logging ensures that you can quickly diagnose and fix any issues that might arise.

Conclusion: Automating Cart Cleanup in Magento 2.2.4

Alright guys, there you have it! We've covered the ins and outs of auto-removing items from the cart after 24 hours in Magento 2.2.4. We've shown you how to create the custom module, set up a cron job, and handle both guest and logged-in users, as well as scenarios where a customer cancels their payment. By implementing these steps, you'll be able to reduce cart abandonment, improve inventory management, and boost the overall user experience on your Magento store. Automating this process is a must-have for any successful e-commerce business. Hopefully, this guide helped you create a more efficient and user-friendly online store. Happy coding and happy selling!

Remember to back up your database before making any changes, and always test in a staging environment first. If you have any questions or run into any issues, don't hesitate to reach out to the Magento community or consult the official Magento documentation. Now go forth and create a better shopping experience for your customers! This is about making your store the best it can be.