> ## Documentation Index
> Fetch the complete documentation index at: https://docs.oneclickdz.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Step 3: Sending Top-Ups

> Submit top-up requests and handle immediate responses

## Overview

Once you've validated all inputs, you're ready to send the top-up request to the OneClickDz API. This guide covers submitting requests, handling responses, and managing your reference system.

<Card title="API Reference" icon="book" href="/en/api-reference/mobile/send-topup">
  View complete API documentation for **POST /v3/mobile/send** endpoint
</Card>

## Basic Top-Up Request

### Simple Example

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.oneclickdz.com/v3/mobile/send \
    -H "Content-Type: application/json" \
    -H "X-Access-Token: YOUR_API_KEY" \
    -d '{
      "plan_code": "PREPAID_DJEZZY",
      "MSSIDN": "0778037340",
      "amount": 500,
      "ref": "order-1730462400-user123"
    }'
  ```

  ```javascript Node.js theme={null}
  const fetch = require('node-fetch');

  async function sendTopUp({ planCode, phone, amount, ref }) {
    const response = await fetch('https://api.oneclickdz.com/v3/mobile/send', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Access-Token': process.env.ONECLICKDZ_API_KEY
      },
      body: JSON.stringify({
        plan_code: planCode,
        MSSIDN: phone,
        amount: amount,
        ref: ref
      })
    });
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.error?.message || 'Request failed');
    }
    
    const data = await response.json();
    
    if (!data.success) {
      throw new Error(data.error?.message || 'Top-up failed');
    }
    
    return {
      topupId: data.data.topupId,
      topupRef: data.data.topupRef,
      newBalance: data.data.newBalance
    };
  }

  // Usage
  try {
    const result = await sendTopUp({
      planCode: 'PREPAID_DJEZZY',
      phone: '0778037340',
      amount: 500,
      ref: `order-${Date.now()}-user123`
    });
    
    console.log('✅ Top-up sent:', result.topupId);
    console.log('Reference:', result.topupRef);
    console.log('New balance:', result.newBalance);
  } catch (error) {
    console.error('❌ Failed:', error.message);
  }
  ```

  ```python Python theme={null}
  import requests
  import json
  import os
  import time

  def send_topup(plan_code, phone, amount, ref):
      """Send a mobile top-up request"""
      response = requests.post(
          'https://api.oneclickdz.com/v3/mobile/send',
          headers={
              'Content-Type': 'application/json',
              'X-Access-Token': os.getenv('ONECLICKDZ_API_KEY')
          },
          json={
              'plan_code': plan_code,
              'MSSIDN': phone,
              'amount': amount,
              'ref': ref
          }
      )
      
      response.raise_for_status()
      data = response.json()
      
      if not data['success']:
          raise Exception(data['error']['message'])
      
      return {
          'topup_id': data['data']['topupId'],
          'topup_ref': data['data']['topupRef'],
          'new_balance': data['data'].get('newBalance')
      }

  # Usage
  try:
      result = send_topup(
          plan_code='PREPAID_DJEZZY',
          phone='0778037340',
          amount=500,
          ref=f'order-{int(time.time())}-user123'
      )
      
      print(f"✅ Top-up sent: {result['topup_id']}")
      print(f"Reference: {result['topup_ref']}")
      print(f"New balance: {result.get('new_balance')}")
  except Exception as error:
      print(f"❌ Failed: {error}")
  ```

  ```php PHP theme={null}
  <?php

  function sendTopUp($planCode, $phone, $amount, $ref) {
      $ch = curl_init('https://api.oneclickdz.com/v3/mobile/send');
      
      $data = [
          'plan_code' => $planCode,
          'MSSIDN' => $phone,
          'amount' => $amount,
          'ref' => $ref
      ];
      
      curl_setopt_array($ch, [
          CURLOPT_POST => true,
          CURLOPT_RETURNTRANSFER => true,
          CURLOPT_HTTPHEADER => [
              'Content-Type: application/json',
              'X-Access-Token: ' . getenv('ONECLICKDZ_API_KEY')
          ],
          CURLOPT_POSTFIELDS => json_encode($data)
      ]);
      
      $response = curl_exec($ch);
      $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
      curl_close($ch);
      
      if ($httpCode !== 200) {
          throw new Exception("HTTP error! status: $httpCode");
      }
      
      $result = json_decode($response, true);
      
      if (!$result['success']) {
          throw new Exception($result['error']['message'] ?? 'Top-up failed');
      }
      
      return [
          'topup_id' => $result['data']['topupId'],
          'topup_ref' => $result['data']['topupRef'],
          'new_balance' => $result['data']['newBalance'] ?? null
      ];
  }

  // Usage
  try {
      $result = sendTopUp(
          'PREPAID_DJEZZY',
          '0778037340',
          500,
          'order-' . time() . '-user123'
      );
      
      echo "✅ Top-up sent: {$result['topup_id']}\n";
      echo "Reference: {$result['topup_ref']}\n";
      echo "New balance: {$result['new_balance']}\n";
  } catch (Exception $error) {
      echo "❌ Failed: {$error->getMessage()}\n";
  }
  ```
</CodeGroup>

### Success Response

```json theme={null}
{
  "success": true,
  "data": {
    "topupId": "6901616fe9e88196b4eb64b0",
    "topupRef": "order-1730462400-user123"
  },
  "meta": {
    "timestamp": "2025-11-01T11:00:00.454Z"
  },
  "requestId": "req_1730462400_abc123"
}
```

## Generating Unique References

Always provide unique references to prevent duplicates and enable tracking:

<CodeGroup>
  ```javascript Node.js theme={null}
  function generateOrderRef(userId) {
    const timestamp = Date.now();
    const random = Math.random().toString(36).substring(2, 8);
    return `${userId}-${timestamp}-${random}`;
  }

  // Examples:
  // user123-1730462400-x7k2p9
  // user456-1730462401-m5n8q3
  ```

  ```python Python theme={null}
  import time
  import random
  import string

  def generate_order_ref(user_id):
      timestamp = int(time.time() * 1000)
      random_str = ''.join(random.choices(string.ascii_lowercase + string.digits, k=6))
      return f"{user_id}-{timestamp}-{random_str}"

  # Examples:
  # user123-1730462400-x7k2p9
  # user456-1730462401-m5n8q3
  ```

  ```php PHP theme={null}
  <?php

  function generateOrderRef($userId) {
      $timestamp = round(microtime(true) * 1000);
      $random = substr(str_shuffle('abcdefghijklmnopqrstuvwxyz0123456789'), 0, 6);
      return "{$userId}-{$timestamp}-{$random}";
  }

  // Examples:
  // user123-1730462400-x7k2p9
  // user456-1730462401-m5n8q3
  ```
</CodeGroup>

## Checking Balance Before Sending

Always verify sufficient balance to prevent failed requests:

<Card title="Balance API Reference" icon="wallet" href="/en/api-reference/account/get-balance">
  Learn more about **GET /v3/account/balance** endpoint
</Card>

<CodeGroup>
  ```javascript Node.js theme={null}
  async function checkBalance() {
    const response = await fetch('https://api.oneclickdz.com/v3/account/balance', {
      headers: {
        'X-Access-Token': process.env.ONECLICKDZ_API_KEY
      }
    });
    
    const data = await response.json();
    
    if (!data.success) {
      throw new Error('Failed to check balance');
    }
    
    return data.data.balance;
  }

  async function sendTopUpWithBalanceCheck({ planCode, phone, amount, ref, requiredBalance }) {
    // Check balance first
    const balance = await checkBalance();
    
    if (balance < requiredBalance) {
      throw new Error(`Insufficient balance. Required: ${requiredBalance} DZD, Available: ${balance} DZD`);
    }
    
    // Proceed with top-up
    return await sendTopUp({ planCode, phone, amount, ref });
  }
  ```

  ```python Python theme={null}
  def check_balance():
      """Check account balance"""
      response = requests.get(
          'https://api.oneclickdz.com/v3/account/balance',
          headers={'X-Access-Token': os.getenv('ONECLICKDZ_API_KEY')}
      )
      
      response.raise_for_status()
      data = response.json()
      
      if not data['success']:
          raise Exception('Failed to check balance')
      
      return data['data']['balance']

  def send_topup_with_balance_check(plan_code, phone, amount, ref, required_balance):
      """Send top-up after checking balance"""
      # Check balance first
      balance = check_balance()
      
      if balance < required_balance:
          raise Exception(f'Insufficient balance. Required: {required_balance} DZD, Available: {balance} DZD')
      
      # Proceed with top-up
      return send_topup(plan_code, phone, amount, ref)
  ```

  ```php PHP theme={null}
  <?php

  function checkBalance() {
      $ch = curl_init('https://api.oneclickdz.com/v3/account/balance');
      
      curl_setopt_array($ch, [
          CURLOPT_RETURNTRANSFER => true,
          CURLOPT_HTTPHEADER => [
              'X-Access-Token: ' . getenv('ONECLICKDZ_API_KEY')
          ]
      ]);
      
      $response = curl_exec($ch);
      curl_close($ch);
      
      $data = json_decode($response, true);
      
      if (!$data['success']) {
          throw new Exception('Failed to check balance');
      }
      
      return $data['data']['balance'];
  }

  function sendTopUpWithBalanceCheck($planCode, $phone, $amount, $ref, $requiredBalance) {
      // Check balance first
      $balance = checkBalance();
      
      if ($balance < $requiredBalance) {
          throw new Exception("Insufficient balance. Required: {$requiredBalance} DZD, Available: {$balance} DZD");
      }
      
      // Proceed with top-up
      return sendTopUp($planCode, $phone, $amount, $ref);
  }
  ```
</CodeGroup>

## Error Handling

Handle common API errors:

<Info>
  See the [Error Handling Reference](/en/api-reference/error-handling) for complete error codes and handling strategies.
</Info>

<CodeGroup>
  ```javascript Node.js theme={null}
  async function sendTopUpSafe(data) {
    try {
      return await sendTopUp(data);
    } catch (error) {
      // Parse error response
      if (error.response) {
        const errorData = error.response.data;
        
        switch (errorData.error?.code) {
          case 'ERR_VALIDATION':
            console.error('Validation error:', errorData.error.message);
            console.error('Field:', errorData.error.details?.field);
            break;
            
          case 'INSUFFICIENT_BALANCE':
            console.error('Insufficient balance');
            console.error('Required:', errorData.error.details?.required);
            console.error('Available:', errorData.error.details?.available);
            break;
            
          case 'DUPLICATED_REF':
            console.error('Duplicate reference');
            console.error('Existing topup:', errorData.error.details?.existingTopupId);
            // Check status of existing topup
            break;
            
          case 'INTERNAL_ERROR':
            console.error('Server error, contact support');
            console.error('Request ID:', errorData.requestId);
            break;
            
          default:
            console.error('Unknown error:', errorData.error?.message);
        }
      }
      
      throw error;
    }
  }
  ```

  ```python Python theme={null}
  def send_topup_safe(data):
      """Send top-up with error handling"""
      try:
          return send_topup(**data)
      except requests.HTTPError as error:
          response_data = error.response.json()
          error_code = response_data['error']['code']
          
          if error_code == 'ERR_VALIDATION':
              print('Validation error:', response_data['error']['message'])
              print('Field:', response_data['error'].get('details', {}).get('field'))
          elif error_code == 'INSUFFICIENT_BALANCE':
              print('Insufficient balance')
              print('Required:', response_data['error']['details']['required'])
              print('Available:', response_data['error']['details']['available'])
          elif error_code == 'DUPLICATED_REF':
              print('Duplicate reference')
              print('Existing topup:', response_data['error']['details']['existingTopupId'])
          elif error_code == 'INTERNAL_ERROR':
              print('Server error, contact support')
              print('Request ID:', response_data['requestId'])
          else:
              print('Unknown error:', response_data['error']['message'])
          
          raise
  ```

  ```php PHP theme={null}
  <?php

  function sendTopUpSafe($data) {
      try {
          return sendTopUp(
              $data['plan_code'],
              $data['phone'],
              $data['amount'],
              $data['ref']
          );
      } catch (Exception $error) {
          // Try to parse error response
          $message = $error->getMessage();
          
          if (strpos($message, 'Validation error') !== false) {
              echo "Validation error\n";
          } elseif (strpos($message, 'Insufficient balance') !== false) {
              echo "Insufficient balance\n";
          } elseif (strpos($message, 'Duplicate reference') !== false) {
              echo "Duplicate reference - check existing order\n";
          } else {
              echo "Error: {$message}\n";
          }
          
          throw $error;
      }
  }
  ```
</CodeGroup>

## Database Integration

Store orders before and after API calls:

<CodeGroup>
  ```javascript Node.js (with Transaction) theme={null}
  async function createTopUpOrder({ userId, planCode, phone, amount }) {
    // Start database transaction
    const transaction = await db.transaction();
    
    try {
      // 1. Generate reference
      const ref = generateOrderRef(userId);
      
      // 2. Get plan details
      const plan = await db.mobilePlans.findOne({
        where: { code: planCode }
      });
      
      const cost = amount * plan.wholesaleCost;
      
      // 3. Check user balance
      const user = await db.users.findOne({
        where: { id: userId },
        lock: true,  // Lock row for update
        transaction
      });
      
      if (user.balance < cost) {
        await transaction.rollback();
        throw new Error('Insufficient user balance');
      }
      
      // 4. Create order record
      const order = await db.orders.create({
        userId,
        ref,
        planCode,
        phone,
        amount,
        cost,
        status: 'PENDING',
        createdAt: new Date()
      }, { transaction });
      
      // 5. Deduct user balance
      await db.users.update({
        balance: user.balance - cost
      }, {
        where: { id: userId },
        transaction
      });
      
      // 6. Send to API
      const result = await sendTopUp({
        planCode,
        phone,
        amount,
        ref
      });
      
      // 7. Update order with API response
      await db.orders.update({
        apiTopupId: result.topupId,
        apiTopupRef: result.topupRef,
        status: 'PROCESSING'
      }, {
        where: { id: order.id },
        transaction
      });
      
      // Commit transaction
      await transaction.commit();
      
      return {
        orderId: order.id,
        topupId: result.topupId,
        ref: ref
      };
      
    } catch (error) {
      // Rollback on any error
      await transaction.rollback();
      throw error;
    }
  }
  ```

  ```python Python (with Transaction) theme={null}
  def create_topup_order(user_id, plan_code, phone, amount, db):
      """Create top-up order with database transaction"""
      with db.transaction() as transaction:
          try:
              # 1. Generate reference
              ref = generate_order_ref(user_id)
              
              # 2. Get plan details
              plan = db.mobile_plans.find_one({'code': plan_code})
              cost = amount * plan['wholesale_cost']
              
              # 3. Check user balance
              user = db.users.find_one_and_lock({'_id': user_id})
              
              if user['balance'] < cost:
                  transaction.rollback()
                  raise Exception('Insufficient user balance')
              
              # 4. Create order record
              order = db.orders.insert_one({
                  'user_id': user_id,
                  'ref': ref,
                  'plan_code': plan_code,
                  'phone': phone,
                  'amount': amount,
                  'cost': cost,
                  'status': 'PENDING',
                  'created_at': datetime.now()
              })
              
              # 5. Deduct user balance
              db.users.update_one(
                  {'_id': user_id},
                  {'$inc': {'balance': -cost}}
              )
              
              # 6. Send to API
              result = send_topup(plan_code, phone, amount, ref)
              
              # 7. Update order with API response
              db.orders.update_one(
                  {'_id': order.inserted_id},
                  {
                      '$set': {
                          'api_topup_id': result['topup_id'],
                          'api_topup_ref': result['topup_ref'],
                          'status': 'PROCESSING'
                      }
                  }
              )
              
              transaction.commit()
              
              return {
                  'order_id': str(order.inserted_id),
                  'topup_id': result['topup_id'],
                  'ref': ref
              }
              
          except Exception as error:
              transaction.rollback()
              raise
  ```

  ```php PHP (with Transaction) theme={null}
  <?php

  function createTopUpOrder($userId, $planCode, $phone, $amount, $db) {
      $db->beginTransaction();
      
      try {
          // 1. Generate reference
          $ref = generateOrderRef($userId);
          
          // 2. Get plan details
          $plan = $db->query(
              "SELECT * FROM mobile_plans WHERE code = ? FOR UPDATE",
              [$planCode]
          )->fetch(PDO::FETCH_ASSOC);
          
          $cost = $amount * $plan['wholesale_cost'];
          
          // 3. Check user balance
          $user = $db->query(
              "SELECT * FROM users WHERE id = ? FOR UPDATE",
              [$userId]
          )->fetch(PDO::FETCH_ASSOC);
          
          if ($user['balance'] < $cost) {
              $db->rollBack();
              throw new Exception('Insufficient user balance');
          }
          
          // 4. Create order record
          $db->query(
              "INSERT INTO orders (user_id, ref, plan_code, phone, amount, cost, status, created_at)
               VALUES (?, ?, ?, ?, ?, ?, 'PENDING', NOW())",
              [$userId, $ref, $planCode, $phone, $amount, $cost]
          );
          
          $orderId = $db->lastInsertId();
          
          // 5. Deduct user balance
          $db->query(
              "UPDATE users SET balance = balance - ? WHERE id = ?",
              [$cost, $userId]
          );
          
          // 6. Send to API
          $result = sendTopUp($planCode, $phone, $amount, $ref);
          
          // 7. Update order with API response
          $db->query(
              "UPDATE orders 
               SET api_topup_id = ?, api_topup_ref = ?, status = 'PROCESSING'
               WHERE id = ?",
              [$result['topup_id'], $result['topup_ref'], $orderId]
          );
          
          $db->commit();
          
          return [
              'order_id' => $orderId,
              'topup_id' => $result['topup_id'],
              'ref' => $ref
          ];
          
      } catch (Exception $error) {
          $db->rollBack();
          throw $error;
      }
  }
  ```
</CodeGroup>

## Async Processing

For better performance, process top-ups asynchronously:

<CodeGroup>
  ```javascript Node.js (with Queue) theme={null}
  const Queue = require('bull');
  const topupQueue = new Queue('topup-processing');

  // Add job to queue
  async function queueTopUp(orderData) {
    const order = await db.orders.create({
      ...orderData,
      status: 'QUEUED'
    });
    
    await topupQueue.add({
      orderId: order.id
    });
    
    return order;
  }

  // Process queue
  topupQueue.process(async (job) => {
    const { orderId } = job.data;
    
    const order = await db.orders.findOne({ where: { id: orderId } });
    
    try {
      // Send top-up
      const result = await sendTopUp({
        planCode: order.planCode,
        phone: order.phone,
        amount: order.amount,
        ref: order.ref
      });
      
      // Update order
      await db.orders.update({
        apiTopupId: result.topupId,
        status: 'PROCESSING'
      }, {
        where: { id: orderId }
      });
      
      // Start status polling (another queue)
      await pollQueue.add({ topupId: result.topupId, orderId });
      
    } catch (error) {
      // Handle error
      await db.orders.update({
        status: 'FAILED',
        errorMessage: error.message
      }, {
        where: { id: orderId }
      });
      
      // Refund user
      await refundUser(order.userId, order.cost);
    }
  });
  ```

  ```python Python (with Celery) theme={null}
  from celery import Celery

  app = Celery('topup', broker='redis://localhost:6379/0')

  @app.task
  def process_topup(order_id):
      """Process top-up asynchronously"""
      order = db.orders.find_one({'_id': order_id})
      
      try:
          # Send top-up
          result = send_topup(
              order['plan_code'],
              order['phone'],
              order['amount'],
              order['ref']
          )
          
          # Update order
          db.orders.update_one(
              {'_id': order_id},
              {
                  '$set': {
                      'api_topup_id': result['topup_id'],
                      'status': 'PROCESSING'
                  }
              }
          )
          
          # Start status polling
          poll_topup_status.delay(result['topup_id'], order_id)
          
      except Exception as error:
          # Handle error
          db.orders.update_one(
              {'_id': order_id},
              {
                  '$set': {
                      'status': 'FAILED',
                      'error_message': str(error)
                  }
              }
          )
          
          # Refund user
          refund_user(order['user_id'], order['cost'])

  # Queue top-up
  def queue_topup(order_data):
      order = db.orders.insert_one({
          **order_data,
          'status': 'QUEUED'
      })
      
      process_topup.delay(str(order.inserted_id))
      
      return order
  ```
</CodeGroup>

## Retry Logic

Implement retry for network errors:

<CodeGroup>
  ```javascript Node.js theme={null}
  async function sendTopUpWithRetry(data, maxRetries = 3) {
    let lastError;
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        return await sendTopUp(data);
      } catch (error) {
        lastError = error;
        
        // Don't retry on validation or duplicate errors
        if (error.code === 'ERR_VALIDATION' || error.code === 'DUPLICATED_REF') {
          throw error;
        }
        
        // Wait before retry (exponential backoff)
        if (attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000; // 2s, 4s, 8s
          console.log(`Retry ${attempt}/${maxRetries} after ${delay}ms...`);
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      }
    }
    
    throw lastError;
  }
  ```

  ```python Python theme={null}
  import time

  def send_topup_with_retry(data, max_retries=3):
      """Send top-up with retry logic"""
      last_error = None
      
      for attempt in range(1, max_retries + 1):
          try:
              return send_topup(**data)
          except Exception as error:
              last_error = error
              
              # Don't retry on validation or duplicate errors
              error_msg = str(error)
              if 'Validation' in error_msg or 'Duplicate' in error_msg:
                  raise
              
              # Wait before retry (exponential backoff)
              if attempt < max_retries:
                  delay = 2 ** attempt  # 2s, 4s, 8s
                  print(f'Retry {attempt}/{max_retries} after {delay}s...')
                  time.sleep(delay)
      
      raise last_error
  ```

  ```php PHP theme={null}
  <?php

  function sendTopUpWithRetry($data, $maxRetries = 3) {
      $lastError = null;
      
      for ($attempt = 1; $attempt <= $maxRetries; $attempt++) {
          try {
              return sendTopUp(
                  $data['plan_code'],
                  $data['phone'],
                  $data['amount'],
                  $data['ref']
              );
          } catch (Exception $error) {
              $lastError = $error;
              
              // Don't retry on validation or duplicate errors
              $errorMsg = $error->getMessage();
              if (strpos($errorMsg, 'Validation') !== false || 
                  strpos($errorMsg, 'Duplicate') !== false) {
                  throw $error;
              }
              
              // Wait before retry (exponential backoff)
              if ($attempt < $maxRetries) {
                  $delay = pow(2, $attempt); // 2s, 4s, 8s
                  echo "Retry {$attempt}/{$maxRetries} after {$delay}s...\n";
                  sleep($delay);
              }
          }
      }
      
      throw $lastError;
  }
  ```
</CodeGroup>

## Best Practices

<AccordionGroup>
  <Accordion title="Always Use Unique References" icon="fingerprint">
    Generate unique `ref` for each request to prevent duplicates and enable tracking.
  </Accordion>

  <Accordion title="Check Balance First" icon="wallet">
    Verify sufficient balance before sending to avoid failed requests.
  </Accordion>

  <Accordion title="Use Database Transactions" icon="database">
    Wrap order creation and balance deduction in transactions for data consistency.
  </Accordion>

  <Accordion title="Process Asynchronously" icon="clock">
    Use queues for better performance and user experience.
  </Accordion>

  <Accordion title="Implement Retry Logic" icon="arrows-rotate">
    Retry network errors with exponential backoff, but not validation errors.
  </Accordion>

  <Accordion title="Log Everything" icon="file-lines">
    Log all requests and responses for debugging and auditing.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Step 4: Status Polling" icon="rotate" href="/en/mobile-topup-guides/4-status-polling">
    Learn how to poll and track top-up status
  </Card>

  <Card title="Check Status by Ref API" icon="tag" href="/en/api-reference/mobile/check-by-ref">
    API docs for GET /v3/mobile/check-ref/:ref
  </Card>

  <Card title="Check Status by ID API" icon="id-card" href="/en/api-reference/mobile/check-by-id">
    API docs for GET /v3/mobile/check-id/:id
  </Card>

  <Card title="Error Handling Reference" icon="triangle-exclamation" href="/en/api-reference/error-handling">
    Complete error handling and recovery guide
  </Card>

  <Card title="Webhooks Setup" icon="webhook" href="/en/webhooks">
    Set up real-time status notifications
  </Card>

  <Card title="Polling Strategies" icon="chart-line" href="/en/polling-strategies">
    Optimize your polling implementation
  </Card>

  <Card title="Transaction History API" icon="list" href="/en/api-reference/account/list-transactions">
    View your transaction history
  </Card>

  <Card title="Balance API" icon="wallet" href="/en/api-reference/account/get-balance">
    Check account balance endpoint
  </Card>
</CardGroup>