Magento 2 Core Events List with Examples for Developers

Magento 2 is a powerful and flexible e-commerce platform, built on a robust event-driven architecture. Events in Magento allow developers to "hook into" specific actions throughout the system without modifying core code. They are widely used to extend functionality, customize workflows, and integrate with other systems.

In this article, you will find a comprehensive table of Magento 2 core events, including the event name, the arguments available, and the file where the event is dispatched. This list focuses solely on default Magento 2 events, ensuring that it is relevant for all standard installations.

Each event can be used in various scenarios, such as:

• Modifying product or category data before saving to the database.
• Performing additional operations after an order is placed, invoiced, or shipped.
• Customizing checkout processes, payment methods, or shipping calculations.
• Tracking customer actions, such as login, logout, or newsletter subscription.
• Extending email templates, CMS page rendering, or catalog search functionality.

After the table, practical examples are provided to demonstrate how to observe events using events.xml and implement custom observers. These examples will help developers understand how to leverage events effectively for custom business logic.

By the end of this article, developers will have a clear reference for Magento 2 core events and practical guidance on using them to create robust, maintainable customizations.

Example: Observing the customer_register_success Event

To react when a customer registers, you can create an observer for the customer_register_success event. Here’s a step-by-step example:

1. Create events.xml in your custom module: app/code/Vendor/Module/etc/frontend/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="customer_register_success">
        <observer name="vendor_module_customer_register" instance="Vendor\Module\Observer\CustomerRegisterObserver" />
    </event>
</config>

2. Create the Observer class: app/code/Vendor/Module/Observer/CustomerRegisterObserver.php

<?php
namespace Vendor\Module\Observer;

use Magento\Framework\Event\ObserverInterface;
use Magento\Framework\Event\Observer;

class CustomerRegisterObserver implements ObserverInterface
{
    public function execute(Observer $observer)
    {
        $customer = $observer->getEvent()->getCustomer();
        // Example: Send a custom welcome message
        $name = $customer->getFirstname();
        $email = $customer->getEmail();
        // Log the registration (or any custom action)
        file_put_contents(BP . '/var/log/customer_register.log', "New customer: $name, $email\n", FILE_APPEND);
    }
}

This observer is automatically triggered whenever a customer completes registration. You can modify it to perform additional tasks, such as sending custom emails, assigning loyalty points, or integrating with external systems.

Example 2: Observing the sales_order_place_after Event

This event is triggered after an order is successfully placed. Observers for this event are commonly used for custom order processing, notifications, or integration with third-party systems.

1. Create events.xml in your custom module: app/code/Vendor/Module/etc/frontend/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="sales_order_place_after">
        <observer name="vendor_module_order_place" instance="Vendor\Module\Observer\OrderPlaceObserver" />
    </event>
</config>

2. Create the Observer class: app/code/Vendor/Module/Observer/OrderPlaceObserver.php

<?php
namespace Vendor\Module\Observer;

use Magento\Framework\Event\ObserverInterface;
use Magento\Framework\Event\Observer;

class OrderPlaceObserver implements ObserverInterface
{
    public function execute(Observer $observer)
    {
        $order = $observer->getEvent()->getOrder();
        $orderId = $order->getIncrementId();
        $grandTotal = $order->getGrandTotal();
        // Example: Log order info
        file_put_contents(BP . '/var/log/order_place.log', "Order #$orderId placed, total: $grandTotal\n", FILE_APPEND);
    }
}

Example 3: Observing the `catalog_category_save_after` Event

This event is triggered after a category is saved. Observers are useful for automatically updating category-related data, syncing with external systems, or performing additional validations.

1. Create events.xml in your custom module: app/code/Vendor/Module/etc/adminhtml/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="catalog_category_save_after">
        <observer name="vendor_module_category_save" instance="Vendor\Module\Observer\CategorySaveObserver" />
    </event>
</config>

2. Create the Observer class: app/code/Vendor/Module/Observer/CategorySaveObserver.php

<?php
namespace Vendor\Module\Observer;

use Magento\Framework\Event\ObserverInterface;
use Magento\Framework\Event\Observer;

class CategorySaveObserver implements ObserverInterface
{
    public function execute(Observer $observer)
    {
        $category = $observer->getEvent()->getCategory();
        $categoryName = $category->getName();
        $categoryId = $category->getId();
        // Example: Log category updates
        file_put_contents(BP . '/var/log/category_save.log', "Category #$categoryId saved: $categoryName\n", FILE_APPEND);
    }
}

With these examples, developers can see how to connect an event to custom logic. The same approach applies to hundreds of Magento 2 core events listed in the table above.

Magento 2's event-driven architecture provides developers with a flexible way to extend functionality without modifying core code. By observing events, you can implement custom logic for a wide range of scenarios, from checkout and order processing to product management and customer interactions.

Here are some best practices and tips when working with events:

• Focus on core events first: Always use core Magento 2 events for standard workflows. Avoid modifying core files.
• Use descriptive observer names: When defining observers in events.xml, choose names that clearly indicate their purpose.
• Keep observers lightweight: Avoid heavy computations inside observers. Offload intensive tasks to cron jobs or asynchronous processes when possible.
• Debugging: Use logging (e.g., var/log) or Xdebug to ensure your observer is triggered as expected.
• Test in a safe environment: Always test new observers on a development or staging site before deploying to production.
• Reuse existing events: Before creating custom events, check if a core event already covers your needs.

By combining the full list of Magento 2 core events with practical examples, you now have a solid reference to develop maintainable, scalable, and robust customizations. Understanding how and when to use these events will greatly improve your efficiency as a Magento 2 developer.