How to Categorize Products for Spryker Commerce OS

Understanding Spryker Product Categorization

Spryker Commerce OS has emerged as one of the most innovative enterprise commerce platforms, offering a fully modular, API-first architecture that empowers businesses to build highly customized commerce experiences. Originally developed in Germany and now trusted by leading European and global enterprises, Spryker's unique approach to commerce technology separates business logic into independent modules that can be composed, extended, and replaced according to specific business requirements. Product categorization within the Spryker ecosystem requires understanding the platform's flexible data model, multi-store capabilities, and the modular nature of its category and product management systems. Our AI-powered categorization API integrates seamlessly with Spryker's architecture, providing intelligent category suggestions that respect your implementation's specific structure.

The Spryker platform implements a sophisticated approach to product organization that goes beyond traditional category hierarchies. At its foundation, Spryker's category system supports hierarchical tree structures with unlimited depth, localized category information across multiple languages, and flexible category-product assignments that enable products to appear in multiple categories simultaneously. What distinguishes Spryker is its clear separation between abstract products (the conceptual product with shared attributes) and concrete products (specific variants with unique SKUs), with categories typically assigned at the abstract product level to maintain consistency across variant families. Understanding this product model is essential for effective AI-powered categorization that produces results aligned with Spryker best practices.

Spryker's modular architecture means that category functionality is provided through dedicated bundles that can be extended or customized for specific business requirements. The Category bundle provides core category management capabilities, while additional bundles like CategoryImage, CategoryPageSearch, and CategoryStorage extend functionality for specific use cases. This extensibility allows enterprises to implement custom category behaviors, additional category attributes, and sophisticated category-based business rules without modifying core platform code. Our categorization API is designed to work with both standard Spryker category implementations and custom extensions, returning predictions that can be applied through Spryker's standard APIs regardless of your specific category bundle configuration.

The platform's marketplace capabilities have made Spryker increasingly popular for enterprise marketplace implementations where multiple merchants sell products through a unified storefront. In marketplace scenarios, category management becomes more complex as merchant products must be mapped to the marketplace's master category structure while potentially maintaining merchant-specific categorizations. Our enterprise categorization API supports these marketplace workflows, understanding the relationship between marketplace categories and merchant product data to provide accurate category suggestions that facilitate efficient merchant onboarding and product catalog integration within Spryker marketplace implementations.

Spryker Category Architecture

Spryker Commerce OS implements a flexible category architecture designed for enterprise commerce requirements while maintaining the platform's core philosophy of modularity and customization. Understanding this architecture is essential for effective AI-powered categorization that produces results compatible with your specific Spryker implementation. The platform's approach to categories emphasizes clean data models, clear separation of concerns, and extensibility through the bundle system.

Categories in Spryker are organized as a tree structure where each category can have a parent category and multiple child categories, creating hierarchical navigation paths that customers use to browse products. Each category is identified by a unique key and numeric ID, with the key providing a human-readable identifier that remains stable across environments and facilitates integration scenarios. Categories support localized attributes including names, meta titles, meta descriptions, and URLs (slugs) for each configured locale, enabling internationalized storefronts with language-appropriate category presentation.

Products in Spryker are assigned to categories at the abstract product level, meaning all concrete product variants inherit the category assignments of their parent abstract product. This design ensures consistent categorization across product variants while simplifying catalog management. Products can belong to multiple categories, with one category designated as the primary category for canonical URL generation and breadcrumb display. Our AI categorization API returns ranked category predictions that can be used for both primary category assignment and identification of secondary categories for enhanced product discoverability.

Common Spryker Category Structures

Spryker's flexibility enables enterprises to define category structures that precisely match their specific business requirements, industry standards, and customer navigation patterns. Our AI models adapt to your custom taxonomy by learning from your existing categorized products, providing predictions that align with your established organizational patterns rather than imposing generic category structures.

API Integration Guide

Integrating our product categorization API with your Spryker Commerce OS implementation aligns with the platform's API-first and modular design philosophy. Whether you're building custom modules, implementing data import pipelines, or extending the Glue API, our RESTful endpoints provide consistent, low-latency categorization services that complement Spryker's native capabilities.

<?php

namespace Pyz\Zed\ProductCategorization\Business;

use GuzzleHttp\Client;
use Generated\Shared\Transfer\ProductAbstractTransfer;

class ProductCategorizationFacade implements ProductCategorizationFacadeInterface
{
    private const API_URL = 'https://www.productcategorization.com/api/ecommerce/ecommerce_category6_get.php';

    public function categorizeProduct(ProductAbstractTransfer $productAbstract, string $apiKey): array
    {
        $client = new Client();

        $query = sprintf(
            '%s %s %s',
            $productAbstract->getName(),
            $productAbstract->getDescription(),
            $productAbstract->getAttributes()['brand'] ?? ''
        );

        $response = $client->get(self::API_URL, [
            'query' => [
                'query' => $query,
                'api_key' => $apiKey,
                'data_type' => 'spryker'
            ]
        ]);

        $result = json_decode($response->getBody(), true);

        return [
            'category_key' => $result['category_key'],
            'category_path' => $result['category'],
            'confidence' => $result['confidence'] ?? 0.95
        ];
    }
}

import requests

def categorize_for_spryker(product_data: dict, api_key: str) -> dict:
    """
    Categorize a product for Spryker Commerce OS
    Returns category key and localized names
    """
    base_url = "https://www.productcategorization.com/api/ecommerce/ecommerce_category6_get.php"

    # Combine product attributes for categorization
    query = f"{product_data['name']} {product_data.get('description', '')} {product_data.get('brand', '')}"

    params = {
        "query": query,
        "api_key": api_key,
        "data_type": "spryker"
    }

    response = requests.get(base_url, params=params)
    result = response.json()

    return {
        "category_key": result['category_key'],
        "category_path": result['category'],
        "confidence": result.get('confidence', 0.95),
        "localized_names": result.get('localized_names', {})
    }

# Example usage
product = {
    "name": "Bosch Professional Angle Grinder GWS 22-230",
    "description": "2200W powerful angle grinder for professional use",
    "brand": "Bosch"
}

result = categorize_for_spryker(product, "your_api_key")
print(f"Category: {result['category_key']}")

curl -X GET "https://www.productcategorization.com/api/ecommerce/ecommerce_category6_get.php" \
  -d "query=Festool TS 55 REBQ-Plus Plunge Cut Saw Professional Woodworking" \
  -d "api_key=your_api_key_here" \
  -d "data_type=spryker"