B2B klantportaal bouwen op Shopify + Laravel

B2B klantportaal bouwen op Shopify + Laravel

Shopify verwerkt $700 miljard aan GMV per jaar. Voor B2C-webshops is het ongekend capabel. Maar een inkoopmanager die een herbestelling wil plaatsen van 47 verschillende producten op basis van vorige maand, klantspecifieke contractprijzen en een factuuroverzicht voor de boekhouding — die persoon heeft meer nodig dan Shopify native biedt.

Shopify is de winkel. Laravel is de brain. Samen bouwen ze een B2B-portaal dat serieus werk verzet.

Wat je leert in dit artikel

• Waarom Shopify alleen niet voldoet voor serieuze B2B
• Welke features een volwassen B2B-portaal nodig heeft
• Hoe de architectuur van Shopify + Laravel eruitziet
• Kostenindicaties per feature set
• Wanneer dit model beter is dan Magento B2B

Waarom Shopify alleen niet genoeg is voor B2B

Shopify heeft de afgelopen jaren fors geïnvesteerd in B2B-functionaliteit. Shopify Plus biedt nu klantspecifieke prijslijsten, company accounts, purchase orders en basic buyer portals.

Maar er zijn grenzen.

De architectuur: Shopify als frontend, Laravel als brain

Klant logt in op portaal
         ↓
Shopify Storefront (productcatalogus, winkelwagen)
         ↓
Laravel Backend (authenticatie, B2B-logica)
  ├── Klantspecifieke prijzen
  ├── Offertemanagement
  ├── Orderhistorie + herbestelling
  ├── Factuuroverzicht
  └── Bulkorder upload (CSV)
         ↓
Shopify Storefront API (order aanmaken)
         ↓
ERP-koppeling (Exact, AFAS, SAP)

De klant ervaart één naadloos portaal. Achter de schermen communiceert Laravel met Shopify via de Storefront API en Admin API. Laravel is de enige plek die weet wie de klant is, welke prijzen hij mag zien en welke orders hij heeft.

Authenticatie

Shopify's native klantaccounts zijn beperkt voor B2B. Laravel beheert de authenticatie via een eigen sessiesysteem of OAuth. Bij inloggen verifieert Laravel de klant, haalt zijn klantprofiel op en configureert de Shopify Storefront API-sessie met de juiste prijslijst.

class B2BAuthController extends Controller
{
    public function login(LoginRequest $request): JsonResponse
    {
        // Verifieer klant in Laravel database
        $customer = $this->customerRepository->findByCredentials(
            $request->email,
            $request->password
        );

        if (! $customer) {
            return response()->json(['error' => 'Ongeldige inloggegevens'], 401);
        }

        // Genereer Shopify multipass token voor naadloze Shopify-sessie
        $multipassToken = $this->shopifyMultipass->generateToken([
            'email'      => $customer->email,
            'created_at' => now()->toIso8601String(),
            'tag_string' => "customer_group:{$customer->customerGroup}",
        ]);

        // Maak Laravel sessie aan met klantcontext
        $token = $customer->createToken('portal')->plainTextToken;

        return response()->json([
            'token'           => $token,
            'multipass_token' => $multipassToken,
            'customer'        => CustomerResource::make($customer),
        ]);
    }
}

Feature 1: klantspecifieke prijzen

Elke B2B-klant heeft zijn eigen prijsafspraken. Een contractprijs voor artikel X, een volumekorting op categorie Y, een vaste marge op het hele assortiment.

Laravel beheert deze prijsafspraken in een flexibel datamodel:

// Prijsmodel: drie niveaus van specificiteit
// 1. Klantspecifieke artikelprijs (meest specifiek)
// 2. Klantgroep staffelprijs (middelmatig)
// 3. Standaard catalogusprijs (meest generiek)

class CustomerPricingService
{
    public function getPriceForCustomer(
        string $sku,
        int $quantity,
        Customer $customer
    ): Price {
        // 1. Check klantspecifieke prijs
        $contractPrice = $this->contractPriceRepository
            ->findForCustomerAndSku($customer->id, $sku, $quantity);

        if ($contractPrice) {
            return $contractPrice;
        }

        // 2. Check klantgroepprijs met staffel
        $groupPrice = $this->groupPriceRepository
            ->findForGroupAndSku($customer->customerGroup, $sku, $quantity);

        if ($groupPrice) {
            return $groupPrice;
        }

        // 3. Terug naar standaard catalogusprijs
        return $this->catalogPriceRepository->findBySku($sku);
    }
}

De prijs wordt via de Storefront API aan Shopify doorgegeven. De klant ziet altijd zijn eigen prijs, nooit de catalogusprijs van een andere klant.

Feature 2: offertemanagement

De offerteflow is voor veel B2B-bedrijven de kern van het verkoopproces. Een klant vraagt een offerte aan, de accountmanager past aan, de klant keurt goed.

Laravel bouwt dit als een stateful workflow:

Bij acceptatie maakt Laravel automatisch een Shopify-order aan via de Admin API, met de overeengekomen prijzen. Geen handmatige orderinvoer meer.

Feature 3: orderhistorie en herbestelling

Een inkoopmanager wil zijn orderhistorie inzien en snel herbestellen. Dat klinkt eenvoudig. De uitdaging zit in de koppeling: orders staan in Shopify én in het ERP. Laravel synchroniseert beide bronnen en toont een geconsolideerd overzicht.

Herbestellen werkt in drie stappen:

1. Klant selecteert een eerdere order
2. Laravel haalt de orderregels op inclusief huidige prijzen
3. Laravel maakt een nieuwe Shopify-winkelwagen aan via de Storefront API, gevuld met de juiste producten en klantprijzen

class ReorderService
{
    public function createReorder(string $originalOrderId, Customer $customer): Cart
    {
        // Haal originele order op uit Shopify of ERP
        $originalOrder = $this->orderRepository->find($originalOrderId);

        // Haal huidige prijzen op voor de klant
        $lineItems = collect($originalOrder->lineItems)->map(function ($item) use ($customer) {
            $currentPrice = $this->pricingService->getPriceForCustomer(
                $item->sku,
                $item->quantity,
                $customer
            );

            return [
                'variantId' => $item->shopifyVariantId,
                'quantity'  => $item->quantity,
                'price'     => $currentPrice->amount,
            ];
        });

        // Maak nieuwe winkelwagen aan in Shopify via Storefront API
        return $this->shopifyCart->create($lineItems, $customer->shopifyCustomerId);
    }
}

De klant ziet de actuele prijs van elk artikel, ook als die gewijzigd is ten opzichte van de originele order. Een verschil groter dan 5% toont Laravel als waarschuwing.

Feature 4: bulkorder via CSV

Grote aankopen worden in B2B vaak als spreadsheet aangeleverd. Een inkoper exporteert zijn bestelbestand uit zijn eigen ERP, uploadt het in het portaal en plaatst in één actie een order van 200 regels.

Laravel verwerkt de CSV, valideert elk artikel (bestaat het SKU? is er voorraad? is er een prijs?), retourneert een preview met totaalbedrag en eventuele waarschuwingen, en maakt bij akkoord de order aan in Shopify.

Feature 5: factuuroverzicht

Zakelijke klanten willen een volledig factuuroverzicht: openstaande facturen, betaalde facturen, deelbetalingen, BTW-specificatie. Shopify biedt dit niet. Laravel koppelt aan het ERP of de boekhoudapplicatie en toont het overzicht in het portaal.

Bij een Exact Online-koppeling:

class InvoiceService
{
    public function getCustomerInvoices(Customer $customer): Collection
    {
        // Haal facturen op uit Exact Online via API
        $exactInvoices = $this->exactApi->getSalesInvoices([
            'filter'   => "DebtorCode eq '{$customer->erpDebtorCode}'",
            'select'   => 'InvoiceID,InvoiceDate,DueDate,AmountDC,OutstandingAmount,Status',
            'orderby'  => 'InvoiceDate desc',
        ]);

        // Normaliseer naar intern datamodel
        return collect($exactInvoices)->map(fn($invoice) => new Invoice(
            id:             $invoice['InvoiceID'],
            date:           Carbon::parse($invoice['InvoiceDate']),
            dueDate:        Carbon::parse($invoice['DueDate']),
            totalAmount:    $invoice['AmountDC'],
            openAmount:     $invoice['OutstandingAmount'],
            status:         $this->mapExactStatus($invoice['Status']),
        ));
    }
}

Kostenindicatie per feature set

De investering hangt af van de complexiteit en het aantal integraties.

Dit zijn indicaties. Bestaande Shopify-setup, ERP-complexiteit en het aantal klantgroepen beïnvloeden de kosten.

Wanneer is Shopify + Laravel beter dan Magento B2B?

Dit is een eerlijke vergelijking. Magento B2B is een volwassen platform met native B2B-features.

• Je huidige Shopify-setup goed werkt voor B2C en je B2B ernaast wil bedienen
• Je sneller live wil dan met een Magento-migratie
• Je maatwerk B2B-logica nodig hebt die niet in Magento past
• Je de frontend-overhead van Magento (hosting, updates, security patches) wil vermijden

• Je een catalogus hebt van meer dan 50.000 producten
• Je complexe multi-store configuraties nodig hebt (verschillende talen, valuta, winkels)
• Je volledig binnen één platform wil blijven
• Je al een Magento-investering hebt staan

Lees meer over onze Shopify-expertise en Laravel-maatwerkontwikkeling.

Conclusie: serieuze B2B vereist serieuze architectuur

Een inkoopmanager die dagelijks via een portaal bestelt, heeft andere eisen dan een consument. Hij wil snelheid, overzicht en klantspecifieke condities. Dat is maatwerk.

Shopify levert de winkelervaring. Laravel levert de intelligentie. Samen bouwen ze een B2B-portaal dat dagelijks operationeel gebruik aankan.

De investering verdient zich terug in minder handmatig werk bij de orderverwerking, hogere klanttevredenheid en een lagere drempel voor herbestelling.

Wil je weten wat een B2B-portaal voor jouw organisatie zou kunnen opleveren? Neem contact op voor een gesprek met een developer, niet een salesmedewerker.

Veelgestelde vragen

Kan ik een B2B-portaal bouwen naast mijn bestaande Shopify B2C-winkel?

Ja. De architectuur scheidt de B2B-logica volledig van de B2C-webshop. Dezelfde Shopify-catalogus, aparte klantaccounts, klantspecifieke prijzen en een eigen portaalinterface. Je B2C-klanten merken niets.

Hoe lang duurt het bouwen van een basaal B2B-portaal?

Voor een basisportaal met login, orderhistorie en herbestelling: 6 tot 10 weken. Een volledig portaal inclusief offertes, factuuroverzicht en ERP-koppeling: 4 tot 6 maanden.

Werkt dit ook met andere e-commerce platforms dan Shopify?

Ja. De Laravel-backend is platform-onafhankelijk. Dezelfde aanpak werkt voor Magento, WooCommerce of een custom frontend. De Storefront API-connectie is platform-specifiek maar vervangbaar.

Hoe beheert een accountmanager klantprijzen in dit systeem?

Via een beheerinterface in Laravel. Accountmanagers kunnen klantspecifieke prijzen, kortingspercentages en geldigheidsperiodes instellen per klant of klantgroep. Zonder dat ze toegang nodig hebben tot Shopify of het ERP.

Is dit model ook geschikt voor een webshop met 50.000+ producten?

Voor catalogi boven de 50.000 producten raden we Magento aan als primair platform. Shopify's Performance kan bij zeer grote catalogi een bottleneck worden. Voor catalogi tot 30.000 producten werkt het Shopify + Laravel model uitstekend.