Integration Patterns

Common integration patterns, best practices, and architectural guidance for Request Network implementations

Overview

This guide covers proven integration patterns, architectural best practices, and common implementation approaches for Request Network. Whether you’re building a simple invoicing system or a complex multi-tenant platform, these patterns will help you implement robust, scalable payment infrastructure.

Common Integration Architectures

Server-Side Integration Pattern

Recommended for production applications requiring security and control.

Architecture

Server-Side Flow:

Frontend → Backend API → Request Network → Blockchain
     ↓
Webhook Handler ← Request Network ← Payment Confirmation
     ↓
Business Logic → Database → Frontend Updates

Benefits:

• Secure API key management
• Centralized business logic
• Reliable webhook handling
• Scalable architecture

Client-Side Integration Pattern

Suitable for simple applications and rapid prototyping.

Architecture

Client-Side Flow:

Frontend App → Request Network SDK → Blockchain
     ↓
Payment Widget → Wallet Connection → Transaction
     ↓
Confirmation → Frontend Updates → Backend Sync

Benefits:

• Faster development
• Reduced backend complexity
• Real-time user feedback
• Lower infrastructure costs

E-commerce Integration Patterns

Shopify Integration

Connect Request Network with Shopify for crypto payment acceptance.

Shopify App Architecture

Integration Components:

• Shopify App with payment gateway registration
• Backend service for Request Network integration
• Webhook handlers for payment confirmation
• Admin dashboard for configuration

Flow:

1. Customer selects crypto payment at checkout
2. Shopify redirects to Request Network payment page
3. Customer completes crypto payment
4. Webhook confirms payment to Shopify
5. Order status updated automatically

Implementation Example

// Shopify payment gateway endpoint
app.post('/shopify/payment/create', async (req, res) => {
  const { order, return_url, cancel_url } = req.body;
  
  // Create Request Network payment request
  const paymentRequest = await requestNetwork.createRequest({
    requestInfo: {
      currency: 'USD',
      expectedAmount: order.total_price,
      payee: { type: 'ethereumAddress', value: merchantAddress }
    },
    contentData: {
      reason: `Shopify Order #${order.order_number}`,
      shopifyOrderId: order.id,
      returnUrl: return_url,
      cancelUrl: cancel_url
    }
  });
  
  // Redirect to payment page
  res.redirect(`/pay/${paymentRequest.requestId}`);
});

// Payment confirmation webhook
app.post('/webhook/payment-confirmed', async (req, res) => {
  const { requestId, paymentHash } = req.body;
  
  // Get order info from Request Network
  const request = await requestNetwork.getRequest(requestId);
  const shopifyOrderId = request.contentData.shopifyOrderId;
  
  // Update Shopify order status
  await shopifyAPI.orders.update(shopifyOrderId, {
    financial_status: 'paid',
    transactions: [{
      kind: 'sale',
      status: 'success',
      amount: request.expectedAmount,
      gateway: 'request-network'
    }]
  });
  
  res.status(200).send('OK');
});

WooCommerce Integration

Enable crypto payments in WordPress/WooCommerce stores.

Plugin Architecture

WordPress Plugin Structure:

• Payment gateway plugin registration
• Admin settings page for configuration
• Checkout integration hooks
• Order status management

Key Features:

• Seamless checkout experience
• Automatic order fulfillment
• Refund handling
• Multi-currency support

PHP Implementation

<?php
// WooCommerce payment gateway class
class WC_Request_Network_Gateway extends WC_Payment_Gateway {
    
    public function __construct() {
        $this->id = 'request_network';
        $this->method_title = 'Request Network';
        $this->method_description = 'Accept crypto payments via Request Network';
        
        $this->init_form_fields();
        $this->init_settings();
        
        // Hook into WooCommerce
        add_action('woocommerce_update_options_payment_gateways_' . $this->id, 
                  array($this, 'process_admin_options'));
        add_action('woocommerce_api_request_network_webhook', 
                  array($this, 'handle_webhook'));
    }
    
    public function process_payment($order_id) {
        $order = wc_get_order($order_id);
        
        // Create Request Network payment request
        $response = wp_remote_post($this->api_endpoint . '/create-request', array(
            'body' => json_encode(array(
                'amount' => $order->get_total(),
                'currency' => $order->get_currency(),
                'order_id' => $order_id,
                'return_url' => $this->get_return_url($order)
            )),
            'headers' => array(
                'Content-Type' => 'application/json',
                'Authorization' => 'Bearer ' . $this->api_key
            )
        ));
        
        $payment_data = json_decode(wp_remote_retrieve_body($response), true);
        
        // Redirect to payment page
        return array(
            'result' => 'success',
            'redirect' => $payment_data['payment_url']
        );
    }
}

SaaS & Subscription Patterns

Multi-Tenant SaaS Architecture

Scale Request Network for multiple customers in a SaaS platform.

Tenant Isolation

Isolation Strategy:

• Separate API keys per tenant
• Namespace separation for requests
• Isolated webhook endpoints
• Tenant-specific fee structures

// Tenant-aware request creation
async function createTenantRequest(tenantId, requestData) {
  const tenantConfig = await getTenantConfig(tenantId);
  
  const request = await requestNetwork.createRequest({
    ...requestData,
    contentData: {
      ...requestData.contentData,
      tenantId,
      tenantDomain: tenantConfig.domain
    },
    paymentNetwork: {
      id: 'erc20-fee-proxy-contract',
      parameters: {
        paymentAddress: tenantConfig.walletAddress,
        feeAddress: platformFeeAddress,
        feeAmount: tenantConfig.platformFeePercentage
      }
    }
  }, {
    apiKey: tenantConfig.requestNetworkApiKey
  });
  
  return request;
}

Enterprise Integration Patterns

ERP System Integration

Connect Request Network with enterprise resource planning systems.

SAP Integration

SAP S/4HANA Integration:

• Invoice creation from SAP sales orders
• Payment status synchronization
• Automatic accounting document creation
• Multi-company and multi-currency support

// SAP integration service
class SAPRequestNetworkIntegration {
  async createInvoiceFromSalesOrder(salesOrderId) {
    // Fetch sales order from SAP
    const salesOrder = await this.sapAPI.getSalesOrder(salesOrderId);
    
    // Create Request Network payment request
    const paymentRequest = await requestNetwork.createRequest({
      requestInfo: {
        currency: salesOrder.currency,
        expectedAmount: salesOrder.totalAmount,
        payee: { type: 'ethereumAddress', value: companyWalletAddress }
      },
      contentData: {
        reason: `Invoice for Sales Order ${salesOrderId}`,
        sapSalesOrderId: salesOrderId,
        sapCustomerId: salesOrder.customerId,
        sapCompanyCode: salesOrder.companyCode
      }
    });
    
    // Update SAP with Request Network details
    await this.sapAPI.updateSalesOrder(salesOrderId, {
      paymentRequestId: paymentRequest.requestId,
      paymentStatus: 'pending'
    });
    
    return paymentRequest;
  }
}

Oracle NetSuite Integration

NetSuite Integration Pattern:

• SuiteScript for Request Network communication
• Custom records for payment tracking
• Automated journal entry creation
• Revenue recognition automation

Microsoft Dynamics Integration

Dynamics 365 Integration:

• Power Platform connectors
• Custom API integration
• Automated invoice processing
• Financial reporting integration

Development Best Practices

Error Handling Strategies

Retry Pattern

class RequestNetworkClient {
  async createRequestWithRetry(requestData, maxRetries = 3) {
    let lastError;
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        return await requestNetwork.createRequest(requestData);
      } catch (error) {
        lastError = error;
        
        // Don't retry on permanent errors
        if (error.code === 'INVALID_REQUEST' || error.code === 'UNAUTHORIZED') {
          throw error;
        }
        
        // Exponential backoff
        const delay = Math.pow(2, attempt) * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
        
        console.log(`Request creation attempt ${attempt} failed, retrying...`);
      }
    }
    
    throw lastError;
  }
}

Performance Optimization

Caching Strategies

Cache Request Data:

// Redis caching for request data
const redis = new Redis(process.env.REDIS_URL);

async function getCachedRequest(requestId) {
  const cacheKey = `request:${requestId}`;
  const cached = await redis.get(cacheKey);
  
  if (cached) {
    return JSON.parse(cached);
  }
  
  const request = await requestNetwork.getRequest(requestId);
  await redis.setex(cacheKey, 300, JSON.stringify(request)); // 5 min cache
  
  return request;
}

What’s Next?

📚 API Reference

Detailed API endpoint documentation and examples

🔑 Get Started

Set up your development environment and API keys

💰 Choose Use Case

Explore specific implementation scenarios