If you've been in the PHP and Laravel ecosystem for a while, chances are you've had to evaluate e-commerce platforms at some point. WooCommerce, Magento, PrestaShop — the market is full of options. But Bagisto is a different case: a platform built natively on Laravel and Vue.js, designed for developers who want real control over their architecture without sacrificing development speed.

In this article I explore Bagisto in depth: its architecture, key features, when it makes sense to use it, and how it compares to other alternatives on the market.

What is Bagisto?

Bagisto is an open source e-commerce framework released in 2018 by Webkul Software. It's built on a stack that many PHP developers already know well:

  • Laravel (backend and business logic)
  • Vue.js (reactive frontend)
  • MySQL / PostgreSQL (persistence)
  • Eloquent ORM (model management)

    • Unlike Magento — which has a brutal learning curve and an architecture that can feel foreign — or WooCommerce — which lives inside the WordPress ecosystem — Bagisto was designed from scratch as a Laravel application. If you already know Laravel, you'll move naturally within the code.

    Official repository: github.com/bagisto/bagisto

    Over 13,000 GitHub stars and an active community with regular releases.

    Technical Architecture

    Package Structure

    Bagisto implements a modular architecture based on Laravel packages. The core is divided into multiple packages within packages/Webkul/:

    packages/
└── Webkul/
    ├── Admin/          # Admin panel
    ├── Attribute/      # EAV attribute system
    ├── Cart/           # Shopping cart
    ├── Catalog/        # Products and categories
    ├── Category/       # Category tree
    ├── Checkout/       # Checkout flow
    ├── Core/           # Base functionalities
    ├── Customer/       # Customer management
    ├── Inventory/      # Inventory control
    ├── Order/          # Order management
    ├── Payment/        # Payment gateways
    ├── Product/        # Product types
    ├── Sales/          # Sales module
    ├── Shipping/       # Shipping methods
    ├── Tax/            # Tax calculation
    └── User/           # Admin user management

    This package separation facilitates maintenance, extensibility, and isolated testing. Each package registers its own routes, views, migrations, and service providers.

    The EAV Model

    Bagisto uses the Entity-Attribute-Value (EAV) pattern for product attributes, similar to Magento. This provides flexibility when defining custom attributes without modifying the database schema. However, like all EAV implementations, it comes with a query complexity cost — something to consider when the catalog scales to hundreds of thousands of products.

    Frontend: Blade + Vue.js

    The admin panel is built with Vue.js and makes heavy use of reactive components. The storefront uses Blade templates with Vue for interactive components (cart, real-time search, filters).

    Bagisto also offers a complete REST and GraphQL API, making it viable as a headless backend for frontends in Next.js, Nuxt, or mobile applications.

    Key Features

    Catalog Management

  • Product types: Simple, Configurable (with variants), Virtual, Downloadable, Grouped, Bundle
  • Custom attributes with types: text, number, date, boolean, select, multiselect, image
  • Attribute groups and reusable attribute families
  • Hierarchical categories with navigation tree
  • Per-product SEO: meta title, meta description, custom URL slug

    • Multi-Channel and Multi-Locale

    One of Bagisto's strengths is its native support for multiple channels, locales, and currencies:

    // Each channel can have its own domain, theme, catalog, and configuration
Channel::create([
    'code'        => 'eu_store',
    'name'        => 'European Store',
    'hostname'    => 'eu.mystore.com',
    'locales'     => ['en', 'de', 'fr', 'es'],
    'currencies'  => ['EUR'],
    'root_category_id' => 2,
]);

    This is especially valuable for projects with an international presence or agencies managing multiple stores from a single installation.

    Pricing System

  • Customer group pricing
  • Catalog pricing (discount rules on products)
  • Cart pricing (coupons, quantity-based rules)
  • Special pricing with start and end dates
  • Multi-currency support with automatic conversion

    • Payment Gateways

    Bagisto includes integrations with:

  • PayPal (Standard, Express, Smart Buttons)
  • Stripe
  • Razorpay
  • PayU
  • Cash on delivery (COD)
  • Bank transfer payment

    • For projects in Costa Rica and Latin America, Stripe integration is fully viable through Stripe Connect, though it's worth validating the local payment method available in each country.

    Inventory Management

  • Stock per product and per variant
  • Multi-warehouse (inventory by warehouse)
  • Low stock alerts
  • Configurable backorders
  • Real-time stock management during checkout

    • Installation and Configuration

    System Requirements

    PHP >= 8.1
Laravel >= 10.x
MySQL >= 8.0 / PostgreSQL >= 13
Composer 2.x
Node.js >= 18.x

    Installation with Composer

    # Create project
composer create-project bagisto/bagisto my-store

cd my-store

# Configure environment variables
cp .env.example .env

# Edit .env with database credentials
# DB_CONNECTION=mysql
# DB_HOST=127.0.0.1
# DB_DATABASE=bagisto_db
# DB_USERNAME=root
# DB_PASSWORD=secret

# Run installer
php artisan bagisto:install

# Compile assets
npm install && npm run build

    The bagisto:install command runs migrations, seeders with initial data, and configures storage. Once complete, the admin panel is available at /admin.

    Installation with Docker

    For development or production environments with Docker:

    # Simplified docker-compose.yml
version: '3.8'

services:
  app:
    image: bagisto/bagisto:latest
    ports:
      - "8000:80"
    environment:
      DB_HOST: db
      DB_DATABASE: bagisto
      DB_USERNAME: bagisto_user
      DB_PASSWORD: secret
    depends_on:
      - db

  db:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: bagisto
      MYSQL_USER: bagisto_user
      MYSQL_PASSWORD: secret
      MYSQL_ROOT_PASSWORD: rootsecret
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

    Extensibility: Creating a Custom Package

    The correct way to extend Bagisto is through Laravel packages. The core is never modified directly.

    php artisan package:make Acme/CustomModule

    This generates the base structure in packages/Acme/CustomModule/:

    CustomModule/
├── src/
│   ├── Config/
│   │   └── menu.php          # Admin menu entries
│   ├── Http/
│   │   ├── Controllers/
│   │   └── Middleware/
│   ├── Models/
│   ├── Repositories/
│   ├── Resources/
│   │   ├── assets/
│   │   └── views/
│   ├── Routes/
│   │   ├── admin-routes.php
│   │   └── shop-routes.php
│   └── Providers/
│       └── CustomModuleServiceProvider.php
└── package.json

    Bagisto uses the Repository pattern instead of accessing models directly, which facilitates testing and implementation substitution:

    // Instead of:
$product = Product::find($id);

// Bagisto uses:
$product = $this->productRepository->find($id);

    REST API and Headless Commerce

    Bagisto exposes a complete REST API under /api/v1/. It enables building decoupled frontends or integrations with external systems.

    # Authentication
POST /api/v1/customer/login

# Catalog
GET /api/v1/products
GET /api/v1/products/{id}
GET /api/v1/categories

# Cart
POST /api/v1/checkout/cart/add
GET  /api/v1/checkout/cart
DELETE /api/v1/checkout/cart/remove/{id}

# Orders
POST /api/v1/checkout/order
GET  /api/v1/orders

    Additionally, Bagisto supports GraphQL through the bagisto/headless-ecommerce package, ideal for projects with frontends in modern frameworks like Nuxt or React.

    Comparison: Bagisto vs Other Platforms

    FeatureBagistoMagento 2WooCommerceSylius
    Base stackLaravel + VueProprietary + KOWordPress + PHPSymfony + Twig
    Learning curveMedium (Laravel)HighLowHigh (Symfony)
    Multi-store✅ Native✅ NativePlugin✅ Native
    REST API✅ Complete✅ Complete✅ Complete✅ Complete
    GraphQL✅ Package✅ NativePlugin❌
    Headless ready✅✅Partial✅
    LicenseMITOSL/EE commercialGPLMIT
    PerformanceHighMedium-LowMediumHigh
    CommunityGrowingLargeVery largeMedium

    When to choose Bagisto:

  • The team already works with Laravel and prefers to stay in that ecosystem
  • Multi-channel/multi-locale is needed from the start
  • You want a headless solution with a robust API
  • The project has deep customization requirements

    • When not to choose Bagisto:

  • You need a massive plugin ecosystem already available (WooCommerce wins here)
  • The team has no experience with Laravel/PHP
  • You're looking for a SaaS solution without infrastructure management (Shopify may be a better option)

    • Performance and Optimization

    Bagisto leverages Laravel's optimization tools:

    # Cache configuration, routes, and views
php artisan config:cache
php artisan route:cache
php artisan view:cache

# Composer optimization
composer install --optimize-autoloader --no-dev

    For production, it's recommended to use:

  • Redis for cache and sessions
  • Queue workers for emails, notifications, and heavy processes
  • CDN for static assets
  • Horizon for queue monitoring

    • Real-World Use Cases

    Bagisto fits especially well in:

  • Development agencies building custom stores for clients who need a solid foundation without reinventing the wheel
  • B2B marketplaces with complex catalogs, multiple pricing tiers, and customer groups
  • Headless projects where the frontend is on a different stack (Next.js, Flutter) and an e-commerce backend with a complete API is needed
  • Regional multi-store with different currencies, languages, and catalogs per country
  • Integration projects with ERPs or legacy systems, leveraging Laravel's flexibility

    • Conclusion

    Bagisto is a serious bet for e-commerce projects that require flexibility, clean architecture, and full control over the code. It's not the simplest option if you need something ready to use in hours, but if your context involves a team with Laravel experience and requirements that go beyond a standard store, it's worth evaluating carefully.

    The bet on Laravel as a foundation guarantees that the code is maintainable, testable, and extensible in ways that more monolithic platforms simply don't allow. And the growing adoption of the headless approach makes its robust API increasingly relevant.

    If you're evaluating Bagisto for a project, I recommend exploring the official repository, reviewing the documentation, and spinning up a local instance with Docker — in less than 30 minutes you'll have a functional environment to evaluate if it suits your needs.

    Resources

  • GitHub Repository: github.com/bagisto/bagisto
  • Official Documentation: devdocs.bagisto.com
  • Slack Community: bagisto.com/slack
  • Extension Marketplace: store.bagisto.com
  • Live Demo: demo.bagisto.com

    • Are you working with Bagisto or evaluating e-commerce platforms for a Laravel project? You can reach me through my portfolio or on GitHub.