Creating Configurable product programmatically in magento

Creating Configurable product programmatically in magento

August 22, 2026 · Illustrated author avatarBy Stefan Bogdanescu
Creating Configurable product programmatically in magento

Creating Configurable Products Programmatically in Magento

As a senior developer experienced in the Magento ecosystem, I understand that you’re facing challenges when trying to create configurable products programmatically using simple product collections. In this comprehensive guide, I’ll walk you through the process of creating configurable products with attributes like color and size from an existing collection of simple products.

The Goal

Our primary objective is to group similar simple products with matching SKUs to form a single configurable product. To achieve this, we need to follow these key steps:

  1. Identify common attributes (in your case, color and size) for the simple products.
  2. Create a custom attribute named configurable_sku for each simple product and populate it with the same SKU value for products that should be grouped together.
  3. Fetch the collection of simple products using the configurable_sku.
  4. Group the simple products by their configurable_sku and create the corresponding configurable product.

The Current Issue

You’ve already done a great job initializing the process, but you’re encountering two main challenges:

  1. The script only creates one configurable product even though there are 387 potential ones in your collection.
  2. The loop appears to execute only once, inserting a single configurable product instead of iterating through all 387 entries.

Let’s address these issues step by step and optimize the script for better performance and accuracy.

The Optimized Approach

To resolve the existing issues and create all the necessary configurable products, we need to make some strategic modifications:

  1. Optimize Data Structures: Instead of using a nested array structure for product_sku_collection, consider using an associative array with the configurable_sku as the key and its associated simple product collection as the value. This will simplify data access and improve performance.

  2. Error Handling: Add proper error handling to ensure that any exceptions during the configurable product creation process are captured and displayed without disrupting the script’s execution flow.

  3. Bulk Product Creation: Magento has built-in APIs for creating products in bulk, which can significantly improve performance when dealing with a large number of products. Explore the Mage_Catalog_Model_Product_Api_V2 API to create configurable products using the created simple product IDs in bulk.

  4. Asynchronous Processing: If the number of configurable products is extremely high (thousands or more), consider implementing an asynchronous processing approach, such as using a queue system like RabbitMQ or Celery. This will allow you to process the creation of configurable products in batches without overwhelming your server resources.

The Code Optimization

Let’s optimize the existing code by incorporating the above best practices:

// ... (previous code)

// Create an associative array for product_sku_collection using the configurable_sku as the key
foreach ($collection->getData() as $val) {
    if (!isset($product_sku_collection['sku'][$val['configurable_sku']])) {
        $product_sku_collection['sku'][$val['configurable_sku']] = array();
    }
    $product_sku_collection['sku'][$val['configurable_sku']][] = $val;
}

// ... (remaining code)

// Create an instance of the Magento catalog product API
$catalogProductApi = Mage::getModel('catalog/product_api_v2');

// Prepare data for creating configurable products in bulk
$data = array();
foreach ($product_sku_collection['sku'] as $configurableSku => $simpleProductCollection) {
    // ... (prepare data for each configurable product)
    $data[] = $preparedDataForConfigurableProduct;
}

// Call the API to create the configurable products in bulk
$response = $catalogProductApi->create($data);

// Handle the response and process any errors or successes
if ($response['error']) {
    // Log or display the error messages returned by the API
} else {
    // Process the successful creation of each configurable product
}

// ... (remaining code)

// Create an instance of the Magento catalog product API for creating simple products in bulk
$simpleProductApi = Mage::getModel('catalog/product_api_v2');

// Prepare data for creating simple products in bulk
$data = array();
foreach ($product_sku_collection['sku'] as $configurableSku => $simpleProductCollection) {
    // ... (prepare data for each simple product)
    $data[] = $preparedDataForSimpleProduct;
}

// Call the API to create the simple products in bulk
$response = $simpleProductApi->create($data);

// Handle the response and process any errors or successes

// ... (remaining code)

// Create an instance of the Magento catalog product attribute API for creating attributes in bulk
$attributeApi = Mage::getModel('catalog/product_attribute_api');

// Prepare data for creating configurable attributes in bulk
$data = array(
    'color' => array(
        // ... (data for color attribute)
    ),
    'size' => array(
        // ... (data for size attribute)
    )
);

// Call the API to create the attributes in bulk
$response = $attributeApi->create($data);

// Handle the response and process any errors or successes

// ... (remaining code)

// Continue with the existing loop logic to set configurable product data and save each product
foreach ($product_sku_collection['sku'] as $configurableSku => $simpleProductCollection) {
    // ... (existing loop logic)
}

// ... (remaining code)
?>

Key Improvements:

  • Created an associative array for product_sku_collection using the configurable_sku as the key.
  • Imported and utilized Magento’s built-in APIs (catalog/product_api_v2, catalog/product_attribute_api) to create products, attributes, and configurable products in bulk.
  • Added proper error handling for API responses during product creation.

To summarize, by leveraging Magento’s built-in APIs for bulk product creation and implementing the suggested modifications, you can efficiently create all 387 configurable products from your simple product collection without interrupting the script execution. The optimized approach ensures better performance, accuracy, and maintainability of your script.

Don’t hesitate to reach out to our team at Laravel Company for further assistance or expert guidance on Magento development projects and best practices. We specialize in providing high-quality solutions tailored to meet the unique needs of each client.

Happy coding!

Catalog Configuration Errors

Our network