Integrating RequestRocket into Your SaaS

# Create dedicated RequestRocket client for enterprise customer
curl -X POST "https://api.requestrocket.com/api/clients" \
  -H "Authorization: $RR_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "clientName": "Enterprise: Acme Corp"
  }'

# 201 { "clients": [{ "clientId": "c4d8e1f0-6a22-4b9c-8d33-1e7a5b0c2d44", "clientName": "Enterprise: Acme Corp", "clientMembers": [] }], "message": "client created successfully" }

# Now create integrations under their dedicated client
curl -X POST "https://api.requestrocket.com/api/clients/c4d8e1f0-6a22-4b9c-8d33-1e7a5b0c2d44/credentials" \
  -H "Authorization: $RR_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "credentialName": "acme-salesforce-proxy",
    "credentialType": "proxy",
    ...
  }'

async function provisionEnterpriseCustomer(customerId, customerName) {
  // Create dedicated RequestRocket client for this customer
  const client = await fetch('https://api.requestrocket.com/api/clients', {
    method: 'POST',
    headers: {
      'Authorization': RR_USER_TOKEN,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      clientName: `Enterprise: ${customerName}`
    })
  }).then(r => r.json());
  
  // Store mapping
  await db.customers.update(customerId, {
    rrClientId: client.clients[0].clientId,
    tier: 'enterprise'
  });
  
  return client;
}

// Now create all their integrations under their own client
async function createEnterpriseIntegration(customerId, platform, credentials) {
  const customer = await db.customers.findById(customerId);
  const clientId = customer.rrClientId; // Their dedicated client
  
  // Create credentials and proxies under their client
  // ... (same as before but using their clientId)
}

def provision_enterprise_customer(customer_id, customer_name):
    """Create dedicated RequestRocket client for enterprise customer"""
    # Create dedicated client
    response = requests.post(
        'https://api.requestrocket.com/api/clients',
        headers={
            'Authorization': RR_USER_TOKEN,
            'Content-Type': 'application/json'
        },
        json={
            'clientName': f'Enterprise: {customer_name}'
        }
    )
    
    client = response.json()
    
    # Store mapping
    db.customers.update(customer_id, {
        'rrClientId': client['clients'][0]['clientId'],
        'tier': 'enterprise'
    })
    
    return client

def create_enterprise_integration(customer_id, platform, credentials):
    """Create integration under customer's dedicated client"""
    customer = db.customers.find_by_id(customer_id)
    client_id = customer['rrClientId']  # Their dedicated client
    
    # Create credentials and proxies under their client
    # ... (same as before but using their client_id)

func provisionEnterpriseCustomer(customerID, customerName string) (*Client, error) {
    // Create dedicated RequestRocket client
    payload := map[string]string{
        "clientName": fmt.Sprintf("Enterprise: %s", customerName),
    }
    
    jsonData, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }
    
    req, err := http.NewRequest(
        "POST",
        "https://api.requestrocket.com/api/clients",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", RR_USER_TOKEN)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var client Client
    if err := json.NewDecoder(resp.Body).Decode(&client); err != nil {
        return nil, err
    }
    
    // Store mapping
    err = db.Customers.Update(customerID, map[string]interface{}{
        "rrClientId": client.Clients[0].ClientID,
        "tier":       "enterprise",
    })
    
    return &client, err
}

func createEnterpriseIntegration(customerID, platform string, credentials map[string]interface{}) error {
    customer, err := db.Customers.FindByID(customerID)
    if err != nil {
        return err
    }
    
    clientID := customer["rrClientId"].(string) // Their dedicated client
    
    // Create credentials and proxies under their client
    // ... (same as before but using their clientID)
    return nil
}

public Client provisionEnterpriseCustomer(String customerId, String customerName) 
    throws IOException {
    // Create dedicated RequestRocket client
    Map<String, String> payload = new HashMap<>();
    payload.put("clientName", "Enterprise: " + customerName);
    
    String json = gson.toJson(payload);
    RequestBody body = RequestBody.create(
        json, 
        MediaType.parse("application/json")
    );
    
    Request request = new Request.Builder()
        .url("https://api.requestrocket.com/api/clients")
        .header("Authorization", RR_USER_TOKEN)
        .header("Content-Type", "application/json")
        .post(body)
        .build();
    
    try (Response response = httpClient.newCall(request).execute()) {
        String responseJson = response.body().string();
        Client client = gson.fromJson(responseJson, Client.class);
        
        // Store mapping
        Map<String, Object> updates = new HashMap<>();
        updates.put("rrClientId", client.clients[0].clientId);
        updates.put("tier", "enterprise");
        db.customers.update(customerId, updates);
        
        return client;
    }
}

public void createEnterpriseIntegration(
    String customerId, 
    String platform, 
    Map<String, Object> credentials
) throws IOException {
    Map<String, Object> customer = db.customers.findById(customerId);
    String clientId = (String) customer.get("rrClientId"); // Their dedicated client
    
    // Create credentials and proxies under their client
    // ... (same as before but using their clientId)
}

# A window limit is a meter, not a rule. See Limits.
# Deny /admin
curl -X POST "https://api.requestrocket.com/api/clients/$SAAS_CLIENT_ID/proxies/$PROXY_ID/rules" \
  -H "Authorization: $RR_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "effect": "deny",
    "ruleActive": true,
    "priority": 800,
    "path": { "path": { "pattern": "^/admin/" }, "presence": "must_exist" },
    "notes": "Admin endpoints restricted"
  }'

# Deny modifications
curl -X POST "https://api.requestrocket.com/api/clients/$SAAS_CLIENT_ID/proxies/$PROXY_ID/rules" \
  -H "Authorization: $RR_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "effect": "deny",
    "ruleActive": true,
    "priority": 850,
    "methods": ["DELETE", "PUT"],
    "notes": "Read-only access"
  }'

async function applyCustomerRules(customerId, proxyId, ruleConfig) {
  const rules = [];
  
  // Example: Rate limit per customer tier
  if (ruleConfig.tier === 'basic') {
    rules.push({
      effect: 'deny',
      ruleActive: true,
      priority: 900,
      notes: 'A request limit is a meter, not a rule',
    });
  }
  
  // Example: Restrict certain endpoints
  if (ruleConfig.restrictedPaths) {
    for (const path of ruleConfig.restrictedPaths) {
      rules.push({
        effect: 'deny',
        ruleActive: true,
        priority: 800,
        path: { path: { pattern: path }, presence: 'must_exist' },
        notes: `Restricted path for ${customerId}`
      });
    }
  }
  
  // Create rules
  for (const rule of rules) {
    await fetch(
      `https://api.requestrocket.com/api/clients/${SAAS_CLIENT_ID}/proxies/${proxyId}/rules`,
      {
        method: 'POST',
        headers: {
          'Authorization': RR_USER_TOKEN,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(rule)
      }
    );
  }
}

def apply_customer_rules(customer_id, proxy_id, rule_config):
    """Apply authorization rules based on customer tier and config"""
    rules = []
    
    # Example: Rate limit per customer tier
    if rule_config.get('tier') == 'basic':
        rules.append({
            'effect': 'deny',
            'ruleActive': True,
            'priority': 900,
            'notes': 'A request limit is a meter, not a rule'
        })
    
    # Example: Restrict certain endpoints
    if rule_config.get('restrictedPaths'):
        for path in rule_config['restrictedPaths']:
            rules.append({
                'effect': 'deny',
                'ruleActive': True,
                'priority': 800,
                'path': { 'path': { 'pattern': path }, 'presence': 'must_exist' },
                'notes': f'Restricted path for {customer_id}'
            })
    
    # Example: Method restrictions (read-only)
    if rule_config.get('readOnly'):
        rules.append({
            'effect': 'deny',
            'ruleActive': True,
            'priority': 850,
            'methods': ['DELETE', 'PUT', 'PATCH'],
            'notes': f'Read-only access for {customer_id}'
        })
    
    # Create rules
    for rule in rules:
        response = requests.post(
            f'https://api.requestrocket.com/api/clients/{SAAS_CLIENT_ID}/proxies/{proxy_id}/rules',
            headers={
                'Authorization': RR_USER_TOKEN,
                'Content-Type': 'application/json'
            },
            json=rule
        )
        response.raise_for_status()

func applyCustomerRules(customerID, proxyID string, ruleConfig map[string]interface{}) error {
    rules := []map[string]interface{}{}
    
    // Example: Rate limit per customer tier
    if tier, ok := ruleConfig["tier"].(string); ok && tier == "basic" {
        rules = append(rules, map[string]interface{}{
            "effect":   "deny",
            "ruleActive": true,
            "priority": 900,
            "notes":    "A request limit is a meter, not a rule",
        })
    }
    
    // Example: Restrict certain endpoints
    if restrictedPaths, ok := ruleConfig["restrictedPaths"].([]string); ok {
        for _, path := range restrictedPaths {
            rules = append(rules, map[string]interface{}{
                "effect":       "deny",
                "ruleActive":   true,
                "priority":     800,
                "path": map[string]interface{}{
                    "path": map[string]string{"pattern": path},
                    "presence": "must_exist",
                },
                "notes":        fmt.Sprintf("Restricted path for %s", customerID),
            })
        }
    }
    
    // Example: Method restrictions (read-only)
    if readOnly, ok := ruleConfig["readOnly"].(bool); ok && readOnly {
        rules = append(rules, map[string]interface{}{
            "effect":         "deny",
            "ruleActive":     true,
            "priority":       850,
            "methods":        []string{"DELETE", "PUT", "PATCH"},
            "notes":          fmt.Sprintf("Read-only access for %s", customerID),
        })
    }
    
    // Create rules
    for _, rule := range rules {
        jsonData, err := json.Marshal(rule)
        if err != nil {
            return err
        }
        
        url := fmt.Sprintf(
            "https://api.requestrocket.com/api/clients/%s/proxies/%s/rules",
            SAAS_CLIENT_ID,
            proxyID,
        )
        
        req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
        if err != nil {
            return err
        }
        
        req.Header.Set("Authorization", RR_USER_TOKEN)
        req.Header.Set("Content-Type", "application/json")
        
        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return err
        }
        resp.Body.Close()
        
        if resp.StatusCode >= 400 {
            return fmt.Errorf("failed to create rule: %d", resp.StatusCode)
        }
    }
    
    return nil
}

public void applyCustomerRules(
    String customerId, 
    String proxyId, 
    Map<String, Object> ruleConfig
) throws IOException {
    List<Map<String, Object>> rules = new ArrayList<>();
    
    // Example: Rate limit per customer tier
    if ("basic".equals(ruleConfig.get("tier"))) {
        Map<String, Object> rule = new HashMap<>();
        rule.put("effect", "deny");
        rule.put("ruleActive", true);
        rule.put("priority", 900);
        rule.put("notes", "A request limit is a meter, not a rule");
        rules.add(rule);
    }
    
    // Example: Restrict certain endpoints
    if (ruleConfig.containsKey("restrictedPaths")) {
        List<String> restrictedPaths = (List<String>) ruleConfig.get("restrictedPaths");
        for (String path : restrictedPaths) {
            Map<String, Object> rule = new HashMap<>();
            rule.put("effect", "deny");
            rule.put("ruleActive", true);
            rule.put("priority", 800);
            Map<String, Object> pathCheck = new HashMap<>();
            pathCheck.put("path", Map.of("pattern", path));
            pathCheck.put("presence", "must_exist");
            rule.put("path", pathCheck);
            rule.put("notes", "Restricted path for " + customerId);
            rules.add(rule);
        }
    }
    
    // Example: Method restrictions (read-only)
    if (Boolean.TRUE.equals(ruleConfig.get("readOnly"))) {
        Map<String, Object> rule = new HashMap<>();
        rule.put("effect", "deny");
        rule.put("priority", 850);
        rule.put("ruleActive", true);
        rule.put("methods", List.of("DELETE", "PUT", "PATCH"));
        rule.put("notes", "Read-only access for " + customerId);
        rules.add(rule);
    }
    
    // Create rules
    String url = String.format(
        "https://api.requestrocket.com/api/clients/%s/proxies/%s/rules",
        SAAS_CLIENT_ID,
        proxyId
    );
    
    for (Map<String, Object> rule : rules) {
        String json = gson.toJson(rule);
        RequestBody body = RequestBody.create(
            json, 
            MediaType.parse("application/json")
        );
        
        Request request = new Request.Builder()
            .url(url)
            .header("Authorization", RR_USER_TOKEN)
            .header("Content-Type", "application/json")
            .post(body)
            .build();
        
        try (Response response = httpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Failed to create rule: " + response.code());
            }
        }
    }
}

# Forward webhook using async endpoint
# Replace /api/ with /async/ in the proxy URL
curl -X POST "https://us-east-2.requestrocket.com/async/my-proxy/webhooks" \
  -H "Authorization: customer-proxy-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "order.created",
    "orderId": "ord_123",
    "timestamp": "2026-01-24T10:30:00Z",
    "data": {
      "amount": 99.99,
      "currency": "USD"
    }
  }'

# Response:
# {
#   "message": "Request accepted for async processing",
#   "requestId": "f3a6c812-9d04-4e75-b1a8-2c0e5d7f9b31",
#   "status": "queued"
# }

# Check webhook delivery status
curl -X GET "https://api.requestrocket.com/api/clients/$SAAS_CLIENT_ID/proxies/$PROXY_ID/requests/$REQUEST_ID" \
  -H "Authorization: $RR_USER_TOKEN"

async function forwardWebhook(customerId, platform, webhookData) {
  const integration = await db.integrations.findOne({
    customerId,
    platform
  });
  
  // Use async endpoint for reliability
  const asyncUrl = integration.proxyUrl.replace('/api/', '/async/');
  
  const response = await fetch(`${asyncUrl}/webhooks`, {
    method: 'POST',
    headers: {
      'Authorization': integration.customerApiKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(webhookData)
  });
  
  const { requestId } = await response.json();
  
  // Track webhook delivery
  await db.webhooks.create({
    customerId,
    platform,
    requestId,
    status: 'queued',
    payload: webhookData
  });
  
  return requestId;
}

def forward_webhook(customer_id, platform, webhook_data):
    """Forward webhook using async API for reliability"""
    integration = db.integrations.find_one({
        'customerId': customer_id,
        'platform': platform
    })
    
    # Use async endpoint for reliability
    async_url = integration['proxyUrl'].replace('/api/', '/async/')
    
    response = requests.post(
        f"{async_url}/webhooks",
        headers={
            'Authorization': integration['customerApiKey'],
            'Content-Type': 'application/json'
        },
        json=webhook_data
    )
    
    result = response.json()
    request_id = result['requestId']
    
    # Track webhook delivery
    db.webhooks.create({
        'customerId': customer_id,
        'platform': platform,
        'requestId': request_id,
        'status': 'queued',
        'payload': webhook_data
    })
    
    return request_id

func forwardWebhook(customerID, platform string, webhookData map[string]interface{}) (string, error) {
    // Get integration
    integration, err := db.Integrations.FindOne(map[string]interface{}{
        "customerId": customerID,
        "platform":   platform,
    })
    if err != nil {
        return "", err
    }
    
    // Use async endpoint for reliability
    proxyURL := integration["proxyUrl"].(string)
    asyncURL := strings.Replace(proxyURL, "/api/", "/async/", 1)
    
    // Marshal webhook data
    jsonData, err := json.Marshal(webhookData)
    if err != nil {
        return "", err
    }
    
    // Send to async endpoint
    req, err := http.NewRequest(
        "POST",
        asyncURL+"/webhooks",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return "", err
    }
    
    req.Header.Set("Authorization", integration["customerApiKey"].(string))
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    var result struct {
        RequestID string `json:"requestId"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return "", err
    }
    
    // Track webhook delivery
    err = db.Webhooks.Create(map[string]interface{}{
        "customerId": customerID,
        "platform":   platform,
        "requestId":  result.RequestID,
        "status":     "queued",
        "payload":    webhookData,
    })
    
    return result.RequestID, err
}

public String forwardWebhook(
    String customerId, 
    String platform, 
    Map<String, Object> webhookData
) throws IOException {
    // Get integration
    Map<String, Object> integration = db.integrations.findOne(
        Map.of("customerId", customerId, "platform", platform)
    );
    
    // Use async endpoint for reliability
    String proxyUrl = (String) integration.get("proxyUrl");
    String asyncUrl = proxyUrl.replace("/api/", "/async/");
    
    // Send to async endpoint
    String json = gson.toJson(webhookData);
    RequestBody body = RequestBody.create(
        json, 
        MediaType.parse("application/json")
    );
    
    Request request = new Request.Builder()
        .url(asyncUrl + "/webhooks")
        .header("Authorization", integration.get("customerApiKey"))
        .header("Content-Type", "application/json")
        .post(body)
        .build();
    
    try (Response response = httpClient.newCall(request).execute()) {
        String responseJson = response.body().string();
        JsonObject result = gson.fromJson(responseJson, JsonObject.class);
        String requestId = result.get("requestId").getAsString();
        
        // Track webhook delivery
        Map<String, Object> webhookRecord = new HashMap<>();
        webhookRecord.put("customerId", customerId);
        webhookRecord.put("platform", platform);
        webhookRecord.put("requestId", requestId);
        webhookRecord.put("status", "queued");
        webhookRecord.put("payload", webhookData);
        
        db.webhooks.create(webhookRecord);
        
        return requestId;
    }
}

# Get request logs for a specific proxy
curl -X GET "https://api.requestrocket.com/api/clients/$SAAS_CLIENT_ID/proxies/$PROXY_ID/requests" \
  -H "Authorization: $RR_USER_TOKEN"

# Response:
# {
#   "message": "Success",
#   "totalRequests": 1,
#   "requests": [
#     { "proxyData": { "status": 200, "duration": 0.234 } }
#   ]
# }

# Get aggregated stats for all customer integrations
# (Requires iterating through each customer's proxies)
for proxy_id in $(get_customer_proxy_ids); do
  curl -X GET "https://api.requestrocket.com/api/clients/$SAAS_CLIENT_ID/proxies/$proxy_id/requests" \
    -H "Authorization: $RR_USER_TOKEN"
done

async function getCustomerUsageStats(customerId, startDate, endDate) {
  const integrations = await db.integrations.find({ customerId });
  
  const stats = await Promise.all(
    integrations.map(async (integration) => {
      const response = await fetch(
        `https://api.requestrocket.com/api/clients/${SAAS_CLIENT_ID}/proxies/${integration.proxyId}/requests?` +
        `processedAfter=${startDate}&processedBefore=${endDate}`,
        {
          headers: { 'Authorization': RR_USER_TOKEN }
        }
      );
      
      const body = await response.json();
      const data = body.requests || [];
      
      return {
        platform: integration.platform,
        totalRequests: body.totalRequests,
        successful: data.filter(r => r.proxyData && r.proxyData.status >= 200 && r.proxyData.status < 300).length,
        failed: data.filter(r => r.proxyData && (r.proxyData.status < 200 || r.proxyData.status >= 300)).length,
        avgDuration: data.reduce((sum, r) => sum + (r.proxyData?.duration || 0), 0) / (data.length || 1)
      };
    })
  );
  
  return {
    customerId,
    period: { startDate, endDate },
    integrations: stats,
    total: stats.reduce((sum, s) => sum + s.totalRequests, 0)
  };
}

def get_customer_usage_stats(customer_id, start_date, end_date):
    """Track usage across all customer integrations"""
    integrations = db.integrations.find({'customerId': customer_id})
    
    stats = []
    for integration in integrations:
        response = requests.get(
            f"https://api.requestrocket.com/api/clients/{SAAS_CLIENT_ID}/proxies/{integration['proxyId']}/requests",
            params={
                'processedAfter': start_date,
                'processedBefore': end_date
            },
            headers={'Authorization': RR_USER_TOKEN}
        )
        
        body = response.json()
        data = body.get('requests') or []
        
        total_requests = body.get('totalRequests', len(data))
        successful = len([r for r in data if 200 <= (r.get('proxyData') or {}).get('status', 0) < 300])
        failed = len([r for r in data if (r.get('proxyData') or {}).get('status', 0) >= 300])
        avg_duration = sum((r.get('proxyData') or {}).get('duration') or 0 for r in data) / total_requests if total_requests else 0
        
        stats.append({
            'platform': integration['platform'],
            'totalRequests': total_requests,
            'successful': successful,
            'failed': failed,
            'avgDuration': avg_duration
        })
    
    return {
        'customerId': customer_id,
        'period': {'startDate': start_date, 'endDate': end_date},
        'integrations': stats,
        'total': sum(s['totalRequests'] for s in stats)
    }

type UsageStats struct {
    Platform      string  `json:"platform"`
    TotalRequests int     `json:"totalRequests"`
    Successful    int     `json:"successful"`
    Failed        int     `json:"failed"`
    AvgDuration   float64 `json:"avgDuration"`
}

type CustomerUsage struct {
    CustomerID   string                 `json:"customerId"`
    Period       map[string]string      `json:"period"`
    Integrations []UsageStats           `json:"integrations"`
    Total        int                    `json:"total"`
}

func getCustomerUsageStats(customerID, startDate, endDate string) (*CustomerUsage, error) {
    integrations, err := db.Integrations.Find(map[string]interface{}{
        "customerId": customerID,
    })
    if err != nil {
        return nil, err
    }
    
    stats := []UsageStats{}
    totalRequests := 0
    
    for _, integration := range integrations {
        url := fmt.Sprintf(
            "https://api.requestrocket.com/api/clients/%s/proxies/%s/requests?processedAfter=%s&processedBefore=%s",
            SAAS_CLIENT_ID,
            integration["proxyId"],
            startDate,
            endDate,
        )
        
        req, _ := http.NewRequest("GET", url, nil)
        req.Header.Set("Authorization", RR_USER_TOKEN)
        
        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()
        
        var result struct {
            TotalRequests int `json:"totalRequests"`
            Requests []struct {
                ProxyData struct {
                    Status   int     `json:"status"`
                    Duration float64 `json:"duration"`
                } `json:"proxyData"`
            } `json:"requests"`
        }
        
        json.NewDecoder(resp.Body).Decode(&result)
        
        successful := 0
        failed := 0
        var totalDuration float64
        
        for _, r := range result.Requests {
            if r.ProxyData.Status >= 200 && r.ProxyData.Status < 300 {
                successful++
            } else if r.ProxyData.Status >= 300 {
                failed++
            }
            totalDuration += r.ProxyData.Duration
        }
        
        avgDuration := float64(0)
        if len(result.Requests) > 0 {
            avgDuration = totalDuration / float64(len(result.Requests))
        }
        
        stat := UsageStats{
            Platform:      integration["platform"].(string),
            TotalRequests: result.TotalRequests,
            Successful:    successful,
            Failed:        failed,
            AvgDuration:   avgDuration,
        }
        
        stats = append(stats, stat)
        totalRequests += result.TotalRequests
    }
    
    return &CustomerUsage{
        CustomerID: customerID,
        Period: map[string]string{
            "startDate": startDate,
            "endDate":   endDate,
        },
        Integrations: stats,
        Total:        totalRequests,
    }, nil
}

public class UsageStats {
    public String platform;
    public int totalRequests;
    public int successful;
    public int failed;
    public double avgDuration;
}

public class CustomerUsage {
    public String customerId;
    public Map<String, String> period;
    public List<UsageStats> integrations;
    public int total;
}

public CustomerUsage getCustomerUsageStats(
    String customerId, 
    String startDate, 
    String endDate
) throws IOException {
    List<Map<String, Object>> integrations = db.integrations.find(
        Map.of("customerId", customerId)
    );
    
    List<UsageStats> stats = new ArrayList<>();
    int totalRequests = 0;
    
    for (Map<String, Object> integration : integrations) {
        String url = String.format(
            "https://api.requestrocket.com/api/clients/%s/proxies/%s/requests?processedAfter=%s&processedBefore=%s",
            SAAS_CLIENT_ID,
            integration.get("proxyId"),
            startDate,
            endDate
        );
        
        Request request = new Request.Builder()
            .url(url)
            .header("Authorization", RR_USER_TOKEN)
            .get()
            .build();
        
        try (Response response = httpClient.newCall(request).execute()) {
            String json = response.body().string();
            JsonObject result = gson.fromJson(json, JsonObject.class);
            JsonArray data = result.getAsJsonArray("requests");
            
            int successful = 0;
            int failed = 0;
            double totalDuration = 0;
            
            for (JsonElement element : data) {
                JsonObject proxyData = element.getAsJsonObject().getAsJsonObject("proxyData");
                int status = proxyData.get("status").getAsInt();
                
                if (status >= 200 && status < 300) {
                    successful++;
                } else if (status >= 300) {
                    failed++;
                }
                
                if (proxyData.has("duration") && !proxyData.get("duration").isJsonNull()) {
                    totalDuration += proxyData.get("duration").getAsDouble();
                }
            }
            
            UsageStats stat = new UsageStats();
            stat.platform = (String) integration.get("platform");
            stat.totalRequests = result.get("totalRequests").getAsInt();
            stat.successful = successful;
            stat.failed = failed;
            stat.avgDuration = data.size() > 0 ? totalDuration / data.size() : 0;
            
            stats.add(stat);
            totalRequests += data.size();
        }
    }
    
    CustomerUsage usage = new CustomerUsage();
    usage.customerId = customerId;
    usage.period = Map.of("startDate", startDate, "endDate", endDate);
    usage.integrations = stats;
    usage.total = totalRequests;
    
    return usage;
}