Top 5 Custom Workflow and CRM Business Ideas for E-commerce Retailers in Highly Competitive Technical Niches
1. AI-Powered Personalized Product Recommendation Engine with Real-time Inventory Sync
In highly competitive technical niches, generic product recommendations fall flat. The key is a dynamic, AI-driven system that not only suggests relevant products but also reacts instantly to inventory fluctuations. This prevents overselling and enhances customer trust. We’ll outline a Python-based recommendation engine integrated with a PostgreSQL database and a Redis cache for real-time inventory checks.
Core Components:
- Data Ingestion: Collect user interaction data (views, clicks, purchases) and product catalog information.
- Recommendation Model: Utilize collaborative filtering (e.g., Surprise library) or content-based filtering (TF-IDF on product descriptions). For advanced personalization, consider hybrid approaches or deep learning models (e.g., TensorFlow/PyTorch).
- Real-time Inventory Check: Integrate with your e-commerce platform’s inventory API or database. Use Redis for fast lookups of stock levels.
- API Endpoint: Expose recommendations via a RESTful API.
Technical Implementation Snippet (Python):
Let’s assume a simplified collaborative filtering approach using the `surprise` library. We’ll also show a basic Redis integration for inventory.
import redis
import pandas as pd
from surprise import Dataset, Reader, KNNBasic
from surprise.model_selection import train_test_split
from surprise import accuracy
# --- Configuration ---
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
PRODUCT_CATALOG_PATH = 'products.csv' # Assume this has product_id, name, description, price
# --- Initialize Redis Client ---
redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)
# --- Load Data ---
# In a real scenario, this would come from your database/API
try:
products_df = pd.read_csv(PRODUCT_CATALOG_PATH)
# Assume user_interactions.csv has user_id, product_id, rating (e.g., 1 for view, 5 for purchase)
interactions_df = pd.read_csv('user_interactions.csv')
except FileNotFoundError:
print("Error: Data files not found. Please ensure 'products.csv' and 'user_interactions.csv' exist.")
exit()
# --- Prepare Data for Surprise ---
reader = Reader(rating_scale=[1, 5]) # Assuming ratings are 1-5
data = Dataset.load_from_df(interactions_df[['user_id', 'product_id', 'rating']], reader)
# --- Train Recommendation Model ---
trainset, testset = train_test_split(data, test_size=0.25)
algo = KNNBasic() # Using basic k-NN collaborative filtering
algo.fit(trainset)
# --- Evaluate Model (Optional but Recommended) ---
predictions = algo.test(testset)
rmse = accuracy.rmse(predictions)
print(f"Model RMSE: {rmse}")
# --- Function to get recommendations with inventory check ---
def get_personalized_recommendations(user_id, n_recommendations=5):
"""
Generates personalized product recommendations for a user,
filtering out out-of-stock items.
"""
recommendations = []
# Get top N predictions for the user
user_predictions = []
for product_id in products_df['product_id'].unique():
# Avoid recommending items the user has already interacted with significantly
if product_id not in interactions_df[interactions_df['user_id'] == user_id]['product_id'].values:
user_predictions.append((product_id, algo.predict(user_id, product_id).est))
# Sort by estimated rating
user_predictions.sort(key=lambda x: x[1], reverse=True)
for product_id, estimated_rating in user_predictions[:n_recommendations * 2]: # Fetch more initially to account for out-of-stock
# --- Real-time Inventory Check using Redis ---
# Assume inventory is stored as 'inventory:product_id' with value as stock count
stock_count_str = redis_client.get(f'inventory:{product_id}')
if stock_count_str:
stock_count = int(stock_count_str)
if stock_count > 0:
product_info = products_df[products_df['product_id'] == product_id].iloc[0]
recommendations.append({
'product_id': product_id,
'name': product_info['name'],
'estimated_rating': round(estimated_rating, 2),
'stock': stock_count
})
else:
# Handle cases where inventory data might be missing in Redis
print(f"Warning: Inventory data not found for product {product_id} in Redis.")
if len(recommendations) >= n_recommendations:
break
return recommendations[:n_recommendations]
# --- Example Usage ---
if __name__ == "__main__":
# --- Simulate Inventory Update in Redis ---
# In a real system, this would be triggered by inventory management events
redis_client.set('inventory:101', '50')
redis_client.set('inventory:102', '0') # Out of stock
redis_client.set('inventory:103', '25')
redis_client.set('inventory:104', '10')
redis_client.set('inventory:105', '5')
redis_client.set('inventory:106', '100')
# --- Get recommendations for a specific user ---
target_user_id = 1
recs = get_personalized_recommendations(target_user_id, n_recommendations=3)
print(f"\nRecommendations for User {target_user_id}:")
for rec in recs:
print(f"- {rec['name']} (ID: {rec['product_id']}), Est. Rating: {rec['estimated_rating']}, Stock: {rec['stock']}")
# --- Example of a user with no prior interactions (fallback needed) ---
# For new users, fall back to popular items or content-based filtering
# This snippet doesn't cover new user handling, which is crucial.
Deployment & Scaling: Deploy this as a microservice. Use a task queue (e.g., Celery with RabbitMQ/Redis) for batch model retraining. Scale Redis and PostgreSQL instances based on traffic and data volume. Monitor recommendation latency and accuracy.
2. Dynamic Pricing Engine with Competitor Price Scraping and Demand Forecasting
In technical niches, product lifecycles can be short, and competitor pricing is aggressive. A static pricing strategy is a losing game. This idea focuses on an automated system that scrapes competitor prices, analyzes demand trends, and adjusts your prices dynamically to maximize profit margins while remaining competitive.
Core Components:
- Competitor Price Scraper: Use tools like Scrapy or BeautifulSoup (Python) to periodically fetch prices from competitor websites. Handle anti-scraping measures (proxies, user-agent rotation, CAPTCHA solving services).
- Demand Forecasting Model: Employ time-series analysis (ARIMA, Prophet) on historical sales data, considering seasonality, promotions, and external factors (e.g., tech news, product launch cycles).
- Pricing Algorithm: Define rules based on competitor prices, your cost of goods, desired margin, and forecasted demand. This could range from simple rule-based systems to reinforcement learning agents.
- Integration with E-commerce Platform: API integration to update product prices automatically.
Technical Implementation Snippet (Python – Scraper & Basic Pricing Logic):
import requests
from bs4 import BeautifulSoup
import time
import pandas as pd
from datetime import datetime, timedelta
# Assume Prophet for demand forecasting is installed: pip install prophet
from prophet import Prophet
import logging
# --- Configuration ---
COMPETITOR_URLS = {
'competitor_a': 'https://example.com/product/tech-gadget-xyz',
'competitor_b': 'https://another-site.net/gadget-xyz-deal'
}
YOUR_PRODUCT_ID = 'my-gadget-xyz'
YOUR_COST_PRICE = 150.00
MIN_MARGIN_PERCENTAGE = 15
MAX_PRICE_ADJUSTMENT_PERCENTAGE = 10 # Limit daily price changes
# --- Logging Setup ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
# --- Competitor Price Scraper ---
def scrape_competitor_prices():
"""Scrapes prices from defined competitor URLs."""
competitor_prices = {}
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
} # Basic User-Agent, needs more sophisticated rotation for production
for name, url in COMPETITOR_URLS.items():
try:
response = requests.get(url, headers=headers, timeout=10)
response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
soup = BeautifulSoup(response.content, 'html.parser')
# --- IMPORTANT: These selectors are highly specific and will break ---
# --- You MUST inspect competitor pages and adapt these selectors ---
price_element = soup.find('span', class_='price') # Example selector
if not price_element:
price_element = soup.find('div', {'data-testid': 'price'}) # Another example
if price_element:
price_text = price_element.get_text().strip()
# Clean the price string (remove currency symbols, commas, etc.)
cleaned_price = ''.join(filter(lambda x: x.isdigit() or x == '.', price_text))
if cleaned_price:
competitor_prices[name] = float(cleaned_price)
logging.info(f"Scraped {name}: ${competitor_prices[name]:.2f}")
else:
logging.warning(f"Could not parse price from {name} ({url}). Raw text: '{price_text}'")
else:
logging.warning(f"Price element not found on {name} ({url}).")
time.sleep(2) # Be polite to servers
except requests.exceptions.RequestException as e:
logging.error(f"Error scraping {name} ({url}): {e}")
except Exception as e:
logging.error(f"Unexpected error processing {name} ({url}): {e}")
return competitor_prices
# --- Demand Forecasting (Simplified Example) ---
def forecast_demand(historical_sales_data_path='sales_history.csv'):
"""
Forecasts future demand using Prophet.
Assumes historical_sales_data_path contains 'ds' (datetime) and 'y' (sales count) columns.
"""
try:
sales_df = pd.read_csv(historical_sales_data_path)
sales_df['ds'] = pd.to_datetime(sales_df['ds'])
model = Prophet(daily_seasonality=True, weekly_seasonality=True, yearly_seasonality=True)
model.fit(sales_df)
future = model.make_future_dataframe(periods=7) # Forecast next 7 days
forecast = model.predict(future)
# Return forecast for the next day
next_day_forecast = forecast.iloc[-1]
logging.info(f"Demand forecast for tomorrow: {next_day_forecast['yhat']:.2f} units")
return next_day_forecast['yhat']
except FileNotFoundError:
logging.warning(f"Sales history file not found: {historical_sales_data_path}. Cannot forecast demand.")
return None
except Exception as e:
logging.error(f"Error during demand forecasting: {e}")
return None
# --- Dynamic Pricing Logic ---
def determine_new_price(competitor_prices, current_price, forecasted_demand):
"""
Determines the optimal price based on competitor prices, cost, margin, and demand.
This is a simplified example. Real-world logic can be much more complex.
"""
if not competitor_prices:
logging.warning("No competitor prices available. Using current price with margin.")
target_price = YOUR_COST_PRICE * (1 + MIN_MARGIN_PERCENTAGE / 100)
return max(target_price, current_price * (1 - MAX_PRICE_ADJUSTMENT_PERCENTAGE / 100)) # Ensure we don't increase price too much if no data
avg_competitor_price = sum(competitor_prices.values()) / len(competitor_prices)
logging.info(f"Average competitor price: ${avg_competitor_price:.2f}")
# --- Pricing Strategy: Aim to be slightly below the lowest competitor, but maintain margin ---
lowest_competitor_price = min(competitor_prices.values())
target_price_based_on_competitors = lowest_competitor_price * 0.98 # 2% below lowest
# --- Ensure minimum margin ---
min_price_with_margin = YOUR_COST_PRICE * (1 + MIN_MARGIN_PERCENTAGE / 100)
# --- Adjust based on demand ---
# If demand is high, we can afford to be closer to the competitor's price or even slightly higher if margin allows.
# If demand is low, we might need to be more aggressive or hold price.
demand_factor = 1.0
if forecasted_demand is not None:
# Example: If forecast is significantly higher than average sales, increase price slightly.
# This requires knowing historical average sales, which is omitted for brevity.
# For simplicity, let's assume higher forecast means we can be more aggressive.
if forecasted_demand > 50: # Arbitrary threshold
demand_factor = 1.02 # Allow slight increase
elif forecasted_demand < 10:
demand_factor = 0.98 # Be more aggressive
final_target_price = max(min_price_with_margin, target_price_based_on_competitors * demand_factor)
# --- Apply constraints: Don't change price too drastically in one go ---
max_allowed_price = current_price * (1 + MAX_PRICE_ADJUSTMENT_PERCENTAGE / 100)
min_allowed_price = current_price * (1 - MAX_PRICE_ADJUSTMENT_PERCENTAGE / 100)
new_price = max(min_allowed_price, min(max_allowed_price, final_target_price))
# Ensure we don't go below cost price + minimum margin
new_price = max(new_price, min_price_with_margin)
return round(new_price, 2)
# --- Main Execution Flow ---
if __name__ == "__main__":
# --- Simulate current price (fetch from your DB/API) ---
current_product_price = 250.00 # Example
# 1. Scrape competitor prices
competitor_prices = scrape_competitor_prices()
logging.info(f"Competitor prices found: {competitor_prices}")
# 2. Forecast demand
forecasted_demand = forecast_demand() # Assumes 'sales_history.csv' exists
# 3. Determine new price
new_price = determine_new_price(competitor_prices, current_product_price, forecasted_demand)
logging.info(f"Current Price: ${current_product_price:.2f}, New Target Price: ${new_price:.2f}")
# --- 4. Update price on e-commerce platform (API call) ---
if new_price != current_product_price:
logging.info(f"Updating price for {YOUR_PRODUCT_ID} to ${new_price:.2f}...")
# Replace with your actual API call to update the product price
# update_product_api(YOUR_PRODUCT_ID, new_price)
else:
logging.info("Price remains unchanged.")
# --- To run demand forecasting daily, you'd schedule this script ---
# --- To run scraping more frequently, adjust the sleep/scheduling ---
Deployment & Scaling: Schedule the scraper to run frequently (e.g., hourly or daily) using cron jobs or a workflow orchestrator like Apache Airflow. The demand forecasting model should be retrained periodically (e.g., weekly). Store historical sales and competitor price data in a time-series database (e.g., InfluxDB) for efficient analysis. Implement robust error handling and monitoring for the scraping process, as it’s prone to external changes.
3. Automated Order Fulfillment & Returns Management with Blockchain Traceability
In technical niches, product authenticity and supply chain transparency are paramount. Customers want assurance that they are buying genuine, high-quality components or devices. Integrating blockchain for order fulfillment and returns adds a layer of trust and immutability.
Core Components:
- E-commerce Platform Integration: Hook into order creation, shipment, and return events.
- Smart Contracts: Deploy smart contracts on a suitable blockchain (e.g., Ethereum, Polygon, Hyperledger Fabric) to manage order status, ownership transfer, and return validation.
- Off-chain Data Storage: Store large order details (images, descriptions) off-chain (e.g., IPFS or a traditional database) and record only hashes on the blockchain for verification.
- Inventory Management System: Link product SKUs to unique blockchain identifiers (e.g., serial numbers).
- Returns Workflow: Automate return authorization based on smart contract conditions and update product status (e.g., “refurbishable,” “parts only”).
Technical Implementation Snippet (Conceptual – Solidity for Smart Contract):
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract OrderFulfillment {
struct Order {
uint256 orderId;
address buyer;
address seller;
uint256 productId; // Reference to product identifier
uint256 quantity;
uint256 price; // In Wei
string productHash; // Hash of product details stored off-chain
string shipmentHash; // Hash of shipment details stored off-chain
OrderStatus status;
bool isReturnInitiated;
bool isReturnCompleted;
}
enum OrderStatus {
PENDING_PAYMENT,
PAID,
SHIPPED,
DELIVERED,
RETURN_REQUESTED,
RETURN_ACCEPTED,
RETURN_REJECTED,
COMPLETED,
CANCELLED
}
mapping(uint256 => Order) public orders;
uint256 public nextOrderId;
event OrderCreated(uint256 indexed orderId, address indexed buyer, uint256 productId, uint256 price);
event OrderShipped(uint256 indexed orderId, string shipmentHash);
event OrderDelivered(uint256 indexed orderId);
event ReturnInitiated(uint256 indexed orderId);
event ReturnCompleted(uint256 indexed orderId);
event OrderStatusChanged(uint256 indexed orderId, OrderStatus newStatus);
// --- Functions for E-commerce Backend ---
function createOrder(address _buyer, uint256 _productId, uint256 _quantity, uint256 _price, string memory _productHash) external returns (uint256) {
require(_buyer != address(0), "Invalid buyer address");
require(_productId > 0, "Invalid product ID");
require(_quantity > 0, "Invalid quantity");
require(_price > 0, "Invalid price");
uint256 currentOrderId = nextOrderId++;
orders[currentOrderId] = Order({
orderId: currentOrderId,
buyer: _buyer,
seller: msg.sender, // Assuming the contract deployer or a registered seller
productId: _productId,
quantity: _quantity,
price: _price,
productHash: _productHash,
shipmentHash: "",
status: OrderStatus.PENDING_PAYMENT,
isReturnInitiated: false,
isReturnCompleted: false
});
emit OrderCreated(currentOrderId, _buyer, _productId, _price);
return currentOrderId;
}
function recordShipment(uint256 _orderId, string memory _shipmentHash) external {
Order storage order = orders[_orderId];
require(order.seller == msg.sender, "Only seller can record shipment");
require(order.status == OrderStatus.PAID, "Order must be paid");
order.shipmentHash = _shipmentHash;
order.status = OrderStatus.SHIPPED;
emit OrderShipped(_orderId, _shipmentHash);
emit OrderStatusChanged(_orderId, OrderStatus.SHIPPED);
}
function recordDelivery(uint256 _orderId) external {
Order storage order = orders[_orderId];
// In a real system, delivery confirmation might come from an oracle or logistics partner
require(order.status == OrderStatus.SHIPPED, "Order must be shipped");
order.status = OrderStatus.DELIVERED;
emit OrderDelivered(_orderId);
emit OrderStatusChanged(_orderId, OrderStatus.DELIVERED);
}
// --- Functions for Customer Interaction ---
function initiateReturn(uint256 _orderId) external {
Order storage order = orders[_orderId];
require(order.buyer == msg.sender, "Only buyer can initiate return");
require(order.status == OrderStatus.DELIVERED, "Order must be delivered to initiate return");
require(!order.isReturnInitiated, "Return already initiated");
// Add logic here: e.g., check return window based on order date
order.isReturnInitiated = true;
order.status = OrderStatus.RETURN_REQUESTED;
emit ReturnInitiated(_orderId);
emit OrderStatusChanged(_orderId, OrderStatus.RETURN_REQUESTED);
}
function approveReturn(uint256 _orderId) external {
Order storage order = orders[_orderId];
require(order.seller == msg.sender, "Only seller can approve return");
require(order.isReturnInitiated, "Return must be initiated first");
require(order.status == OrderStatus.RETURN_REQUESTED, "Return request must be pending approval");
// Add logic for seller to inspect returned item (e.g., via off-chain confirmation)
order.status = OrderStatus.RETURN_ACCEPTED;
emit OrderStatusChanged(_orderId, OrderStatus.RETURN_ACCEPTED);
}
function completeReturn(uint256 _orderId) external {
Order storage order = orders[_orderId];
require(order.buyer == msg.sender || order.seller == msg.sender, "Only buyer or seller can complete return");
require(order.status == OrderStatus.RETURN_ACCEPTED, "Return must be accepted");
order.isReturnCompleted = true;
order.status = OrderStatus.COMPLETED; // Or a specific 'RETURNED' status
emit ReturnCompleted(_orderId);
emit OrderStatusChanged(_orderId, OrderStatus.COMPLETED);
// Trigger refund logic via backend integration
}
// --- Helper Functions ---
function getOrderStatus(uint256 _orderId) external view returns (OrderStatus) {
return orders[_orderId].status;
}
function getOrderDetails(uint256 _orderId) external view returns (
uint256 orderId,
address buyer,
address seller,
uint256 productId,
uint256 quantity,
uint256 price,
string memory productHash,
string memory shipmentHash,
OrderStatus status,
bool isReturnInitiated,
bool isReturnCompleted
) {
Order storage order = orders[_orderId];
return (
order.orderId,
order.buyer,
order.seller,
order.productId,
order.quantity,
order.price,
order.productHash,
order.shipmentHash,
order.status,
order.isReturnInitiated,
order.isReturnCompleted
);
}
}
Integration Notes: Use Web3 libraries (e.g., `web3.js` for JavaScript, `web3.py` for Python) to interact with the smart contracts from your backend. Implement oracles for external data feeds (e.g., shipment tracking confirmation). Ensure secure management of private keys for backend interactions.
4. Subscription Box Management with Tiered Service Levels & Automated Billing
For recurring revenue in technical niches, subscription boxes are powerful. Think curated kits for electronics hobbyists, specialized software licenses with bundled support, or hardware-as-a-service. This requires a robust system for managing different subscription tiers, product configurations, and automated billing.
Core Components:
- Subscription Plan Management: Define tiers (e.g., Basic, Pro, Enterprise) with varying features, product inclusions, and pricing.
- Product Configuration Engine: Allow customers to customize their box within defined parameters for each tier.
- Recurring Billing System: Integrate with payment gateways (Stripe, Braintree) that support recurring payments. Handle failed payments, retries, and dunning.
- Fulfillment Automation: Generate pick lists and shipping labels based on subscription configurations and delivery schedules.
- Customer Portal: Allow users to manage their subscriptions, update payment methods, and view order history.
Technical Implementation Snippet (PHP – Subscription Logic Example):
<?php
// --- Configuration ---
define('STRIPE_SECRET_KEY', 'sk_test_YOUR_SECRET_KEY');
define('STRIPE_WEBHOOK_SECRET', 'whsec_YOUR_WEBHOOK_SECRET');
// --- Assume a database connection is established ($db) ---
// --- Assume Product & Subscription Plan data is in the database ---
// --- Mock Product & Plan Data ---
$products = [
1 => ['name' => 'Raspberry Pi 4', 'sku' => 'RPi4-128', 'price' => 75.00],
2 => ['name' => 'Arduino Uno', 'sku' => 'ARD-UNO', 'price' => 25.00],
3 => ['name' => '32GB SD Card', 'sku' => 'SD32-CLASS10', 'price' => 15.00],
4 => ['name' => 'Premium Support License', 'sku' => 'PSL-PRO', 'price' => 50.00],
5 => ['name' => 'Cloud Compute Hours (100)', 'sku' => 'CLOUD-100', 'price' => 20.00],
];
$subscription_plans = [
'basic' => ['name' => 'Basic Maker Kit', 'description' => 'Get started with essential components.', 'price_id' => 'price_basic_monthly', 'included_products' => [1, 3]],
'pro' => ['name' => 'Pro Developer Box', 'description' => 'Advanced components and support.', 'price_id' => 'price_pro_monthly', 'included_products' => [1, 2, 3, 4]],
'enterprise' => ['name' => 'Enterprise Solution', 'description' => 'Custom hardware and dedicated support.', 'price_id' => 'price_enterprise_monthly', 'included_products' => [1, 2, 4, 5]],
];
// --- Stripe API Initialization ---
\Stripe\Stripe::setApiKey(STRIPE_SECRET_KEY);
// --- Function to create a new subscription ---
function create_customer_subscription(string $customerId, string $planKey, array $customizations = []): ?string {
global $subscription_plans, $products;
if (!isset($subscription_plans[$planKey])) {
error_log("Subscription plan '$planKey' not found.");
return null;
}
$plan = $subscription_plans[$planKey];
$stripePriceId = $plan['price_id'];
$finalPrice = 0;
$includedItems = [];
// Calculate total price and prepare line items based on plan and customizations
foreach ($plan['included_products'] as $productId) {
if (isset($products[$productId])) {
$includedItems[] = [
'price' => $products[$productId]['stripe_price_id'] ?? null, // Assume price IDs are also stored
'quantity' => 1,
];
$finalPrice += $products[$productId]['price'];
}
}
// Add custom items if any (e.g., extra licenses, more compute hours)
// This requires a more complex mapping of customizations to Stripe Price IDs
// For simplicity, we'll assume customizations are handled by updating the plan's price directly or adding one-off items.
// A robust system would involve dynamic price creation or metadata.
try {
// Create a Checkout Session for subscription creation
$checkout_session = \Stripe\Checkout\Session::create([
'customer' => $customerId,
'line_items' => [[
'price' => $stripePriceId, // The base subscription price
'quantity' => 1,
]],
// Add custom items as separate line items if needed, or handle via metadata/update logic
// 'line_items' => array_merge($includedItems, $customizationLineItems),
'mode' => 'subscription',
'allow_promotion_codes' => true,
'success_url' => 'https://your-ecommerce.com/subscription/success?session_id={CHECKOUT_SESSION_ID}',
'cancel_url' => 'https://your-ecommerce.com/subscription/cancel',
'subscription_data' => [
// Metadata can be used to store custom product IDs or configurations
'metadata' => ['plan_key' => $planKey] + $customizations,
],
]);
return $checkout_session->id; // Return session ID to redirect user
} catch (\Exception $e) {
error_log("Stripe Checkout Session creation failed: " . $e->getMessage());
return null;
}
}
// --- Function to handle Stripe Webhook Events ---
function handle_stripe_webhook(string $payload, string $sig_header): void {
$event = null;
try {
$event = \Stripe\Webhook::constructEvent(
$payload, $sig_header, STRIPE_WEBHOOK_SECRET
);
} catch(\UnexpectedValueException $e) {
// Invalid payload
http_response_code(400);
echo json_encode(['error' => 'Invalid payload']);
return;
} catch(\Stripe\Exception\SignatureVerificationException $e) {
// Invalid signature
http_response_code(400);
echo json_encode(['error' => 'Invalid signature']);
return;
}
// Handle the event
switch ($event->type) {
case 'checkout.session.completed':
$session = $event->data->object;
// Fulfill the purchase (e.g., create subscription in your DB)
if ($session->mode === 'subscription') {
$customerId = $session->customer;
$subscriptionId = $session->subscription;
$planKey = $session->subscription_data->metadata['plan_key'] ?? null;
// Process customizations from metadata if needed
// --- Store subscription details in your database ---
// Example: save_subscription_to_db($customerId, $subscriptionId, $planKey, $session->metadata);
error_log("Subscription created: Customer ID {$customerId}, Subscription ID {$subscriptionId}, Plan: {$planKey}");
}
break;
case 'invoice.payment_failed':
$invoice = $event->data->object;
// Handle failed payment (e.g., notify customer, start dunning process)
$subscriptionId = $invoice->subscription;
error_log("Invoice payment failed for subscription: {$subscriptionId}");
break;
case 'customer.subscription.deleted':
$subscription = $event-&