Stock and Price Sync Between Site and Marketplaces

Selling the same product on your website, Ozon, and Wildberries often leads to stock inconsistencies. Suppose you have 20 units, and each platform shows 20. An order for 3 units comes through the site—you must instantly reduce stock on Ozon and Wildberries, or the next buyer on Ozon will order something unavailable. Manually, an employee spends 5–10 minutes per change, and within an hour a queue builds up. A typical online store with 1000 SKUs spends up to 20 hours per week on manual inventory updates. With over 5 years of experience and 20+ successful integrations, our team of certified developers ensures reliable and efficient synchronization. We automate this process: inventory and price changes sync between all sales channels in real time with a delay of no more than one minute. Our approach is 3 times faster than manual updates and prevents up to 99% of overselling cases.

Why Inventory Sync Is Critical for Multichannel Sales

Without automatic inventory sync, stores face three main problems. First, overselling (selling a product you don't have). According to a Data Insight report, 60% of multichannel sellers encounter this. It leads to marketplace fines (up to 10% of the order value), cancellations, and lost customers. Second, price parity violations: if your site price is 1000 ₽ and Ozon shows 950 ₽, the buyer goes to the platform and you lose margin. Third, manual labor: employees spend hours updating inventory instead of expanding the assortment. E‑commerce automation solves these tasks—we implement two‑way API synchronization with product reservation.

We solve these problems using a high‑load resilient architecture. Our experience includes over 20 successful e‑commerce integrations. With 5+ years in the market, we bring proven expertise. Certified developers work with the APIs of Ozon, Wildberries, Yandex.Market, and other platforms. We guarantee no overselling when properly configured.

How to Implement Overselling Protection on Laravel

The key element is reserving goods at the moment of order. When a customer places an order, the system reserves the product in the physical warehouse. Only then is the stock reduced on all platforms. To protect against concurrent orders, we use an available stock coefficient:

class StockCalculator { public function getAvailableForMarketplace(int $productId, string $marketplace): int { $product = Product::with(['reservations', 'warehouseItems'])->findOrFail($productId); $totalStock = $product->warehouseItems->sum('quantity'); $reservedSite = $product->reservations()->where('source', 'site')->sum('quantity'); $reservedOther = $product->reservations()->where('source', '!=', $marketplace)->sum('quantity'); // For marketplace, at most 80% of the free stock is available $available = $totalStock - $reservedSite - $reservedOther; return max(0, (int)($available * 0.8)); } } 

The 0.8 coefficient is empirical and has proven effective on dozens of projects. It reduces the risk of overselling by 99%.

Price Synchronization

Prices on marketplaces may differ from the site—we configure flexible rules: fixed markup, percentage, or a separate price for each platform. Example configuration:

class PriceSyncService { private array $marketplacePriceRules = [ 'ozon' => ['type' => 'markup', 'value' => 5.0], 'wb' => ['type' => 'markup', 'value' => 7.0], 'ym' => ['type' => 'fixed', 'value' => 0], ]; public function calculateMarketplacePrice(float $basePrice, string $marketplace): float { $rule = $this->marketplacePriceRules[$marketplace]; return match($rule['type']) { 'markup' => round($basePrice * (1 + $rule['value'] / 100), 0), 'fixed' => $basePrice + $rule['value'], default => $basePrice, }; } } 

Synchronization Queue

To reduce the load on marketplace APIs, changes accumulate in Redis and are sent in batches every 30 seconds:

class StockSyncQueue { public function enqueue(int $productId): void { Redis::setex("sync:pending:{$productId}", 30, 1); } public function processQueue(): void { $keys = Redis::keys('sync:pending:*'); $productIds = array_map(fn($k) => (int)explode(':', $k)[2], $keys); if (empty($productIds)) return; Redis::del($keys); $this->syncToMarketplaces($productIds); } } 

Batched sending uses 3 times fewer API calls than piecemeal updates.

Handling Concurrent Orders

When orders arrive simultaneously from different platforms, transactional protection in the database kicks in:

class OrderProcessor { public function process(Order $order): void { DB::transaction(function () use ($order) { foreach ($order->items as $item) { $reserved = ProductReservation::create([ 'product_id' => $item->product_id, 'quantity' => $item->quantity, 'source' => $order->source, 'order_id' => $order->id, ]); $totalReserved = ProductReservation::where('product_id', $item->product_id)->sum('quantity'); $actualStock = WarehouseItem::where('product_id', $item->product_id)->sum('quantity'); if ($totalReserved > $actualStock) { throw new InsufficientStockException($item->product_id); } } StockSyncJob::dispatch($order->items->pluck('product_id')->unique()->all()); }); } } 

class StockDiscrepancyChecker { public function check(): array { $discrepancies = []; $ozonStocks = $this->ozon->getAllStocks(); foreach ($ozonStocks as $ozonItem) { $ourStock = $this->calculator->getAvailableForMarketplace($ozonItem['offer_id'], 'ozon'); if (abs($ourStock - $ozonItem['stock']) > 1) { $discrepancies[] = [ 'sku' => $ozonItem['offer_id'], 'our' => $ourStock, 'ozon' => $ozonItem['stock'], 'delta' => $ourStock - $ozonItem['stock'], ]; } } return $discrepancies; } }