Query Card Funding Orders

Overview

Use this endpoint to query top-up and withdrawal transaction orders for your cards. This is essential for tracking card funding operations, reconciliation, and financial reporting. You can filter by card ID, order ID, status, or date range.

NOTE: This API is offered on a client-by-client approval basis. Speak to your account manager to check eligibility.

Resource Access

Production (api.ahrvo.network)

GET https://api.ahrvo.network/card/issuance/api/issuing/card/v2/funding/list

Staging (gateway.ahrvo.network)

GET https://gateway.ahrvo.network/card/issuance/api/issuing/card/v2/funding/list

---

Request Headers

Header	Value	Required	Description
Accept	application/json	Yes	Content type for the response
Authorization	Bearer {access_token}	Yes	Bearer token for authentication
x-api-key	API Key	Yes	API key for authentication

Query Parameters

Parameter	Type	Required	Description
page_no	integer	No	Page number, start from 1 (default: 1)
page_size	integer	No	Number of results per page (default: 20)
start_date	string	No	Create order time from (format: yyyy-MM-dd HH:mm:ss)
end_date	string	No	Create order time to (format: yyyy-MM-dd HH:mm:ss)
status	string	No	Order status: SUCCESS, FAIL, PROCESSING
unique_order_id	string	No	Your unique order ID provided at top-up/withdrawal
card_id	string	No	A unique ID of the card

Response

Success Response (200 OK)

{
  "code": "SUCCESS",
  "data": {
    "total_num": 3,
    "list": [
      {
        "record_id": "1cc24f5b-5dda-4c2f-8811-df2047469f9f",
        "unique_order_id": "ceda673a-62a0-4375-a55f-86d43ea89e9d",
        "created": "2026-01-13",
        "amount": "770.38",
        "currency": "USD",
        "card_number": "8199********9556",
        "card_id": "card4777068445",
        "remark": "sample top-up order",
        "status": "SUCCESS",
        "operate_type": "card_in"
      },
      {
        "record_id": "1cc24f5b-5dda-4c2f-8811-df2047469f5f",
        "unique_order_id": "ceda673a-62a0-4375-a55f-86d43ea89e8d",
        "created": "2025-01-02",
        "amount": "995.41",
        "currency": "USD",
        "card_number": "8199********9556",
        "card_id": "card2389300408",
        "remark": "sample top-up order",
        "status": "SUCCESS",
        "operate_type": "card_in"
      },
      {
        "record_id": "24ba8059-4e86-4168-a0f9-f25f4b268218",
        "unique_order_id": "2e7b6ded-1b36-4141-9c6c-5e8a3d6f8374",
        "created": "2025-05-24",
        "amount": "156.12",
        "currency": "USD",
        "card_number": "8199********9556",
        "card_id": "card9280897222",
        "remark": "sample withdrawal order",
        "status": "SUCCESS",
        "operate_type": "card_out"
      }
    ]
  }
}

Response Fields

Field	Type	Description
code	string	Status string indicating the result. "SUCCESS" refers to a successful query
data	object	Response data object
data.total_num	integer	Total number of orders meeting the query conditions
data.list	array	List of order details
data.list[].record_id	string	A unique ID of the order assigned by PingPong
data.list[].unique_order_id	string	Your unique order ID provided at top-up/withdrawal
data.list[].created	string	Order create time (format: yyyy-MM-dd HH:mm:ss)
data.list[].amount	string	The amount of funds topped up or withdrawn
data.list[].currency	string	Order currency (e.g., USD)
data.list[].card_number	string	Masked card number (e.g., 5157****8888)
data.list[].card_id	string	A unique ID of the card
data.list[].remark	string	Optional description to identify the card
data.list[].status	string	Order status: SUCCESS, FAIL, PROCESSING
data.list[].operate_type	string	Operation type: card_in (top-up) or card_out (withdrawal)

Error Responses

• 400 Bad Request: Invalid query parameters
• 401 Unauthorized: Invalid or missing authentication token
• 403 Forbidden: Card issuance feature not enabled for this account

Code Examples

cURL

curl -X GET \
  'https://gateway.ahrvo.network/card/issuance/api/issuing/card/v2/funding/list?card_id=card4777068445&status=SUCCESS&page_size=10' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN' \
  -H 'x-api-key: YOUR_API_KEY'

Python

import requests

url = "https://gateway.ahrvo.network/card/issuance/api/issuing/card/v2/funding/list"
headers = {
    "Accept": "application/json",
    "Authorization": "Bearer YOUR_ACCESS_TOKEN",
    "x-api-key": "YOUR_API_KEY"
}
params = {
    "card_id": "card4777068445",
    "status": "SUCCESS",
    "page_size": 10
}

response = requests.get(url, headers=headers, params=params)
result = response.json()

if result['code'] == 'SUCCESS':
    total = result['data']['total_num']
    orders = result['data']['list']
    
    print(f"Total funding orders: {total}")
    print(f"Retrieved: {len(orders)} orders\n")
    
    for order in orders:
        operation = "Top-up" if order['operate_type'] == 'card_in' else "Withdrawal"
        print(f"{operation} Order:")
        print(f"  Order ID: {order['unique_order_id']}")
        print(f"  Amount: {order['currency']} {order['amount']}")
        print(f"  Card: {order['card_number']}")
        print(f"  Status: {order['status']}")
        print(f"  Created: {order['created']}\n")
else:
    print(f"Failed to query orders: {result}")

JavaScript (Node.js)

const axios = require('axios');

const url = 'https://gateway.ahrvo.network/card/issuance/api/issuing/card/v2/funding/list';
const headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
  'x-api-key': 'YOUR_API_KEY'
};
const params = {
  card_id: 'card4777068445',
  status: 'SUCCESS',
  page_size: 10
};

axios.get(url, { headers, params })
  .then(response => {
    const result = response.data;
    
    if (result.code === 'SUCCESS') {
      const total = result.data.total_num;
      const orders = result.data.list;
      
      console.log(`Total funding orders: ${total}`);
      console.log(`Retrieved: ${orders.length} orders\n`);
      
      orders.forEach(order => {
        const operation = order.operate_type === 'card_in' ? 'Top-up' : 'Withdrawal';
        console.log(`${operation} Order:`);
        console.log(`  Order ID: ${order.unique_order_id}`);
        console.log(`  Amount: ${order.currency} ${order.amount}`);
        console.log(`  Card: ${order.card_number}`);
        console.log(`  Status: ${order.status}`);
        console.log(`  Created: ${order.created}\n`);
      });
    }
  })
  .catch(error => {
    console.error('Failed to query orders:', error.response.data);
  });

Usage Notes

• Operation Types: card_in = top-up (adding funds), card_out = withdrawal (removing funds)
• Order Status: SUCCESS = completed, FAIL = failed, PROCESSING = in progress
• Pagination: Use pagination for large result sets
• Date Format: Use yyyy-MM-dd HH:mm:ss for date parameters
• Masked Card Numbers: Card numbers are automatically masked for security
• Reconciliation: Use unique_order_id for order tracking and reconciliation

Common Use Cases

Query All Funding Orders for a Card

Retrieve complete funding history for a specific card:

def get_card_funding_history(card_id):
    """
    Get complete funding history for a card with pagination
    """
    all_orders = []
    page_no = 1
    page_size = 50
    
    print(f"Fetching funding history for card {card_id}...\n")
    
    while True:
        params = {
            "card_id": card_id,
            "page_no": page_no,
            "page_size": page_size
        }
        
        response = query_card_funding_orders(params)
        
        if response['code'] == 'SUCCESS':
            data = response['data']
            orders = data['list']
            total = data['total_num']
            
            all_orders.extend(orders)
            
            print(f"Page {page_no}: Retrieved {len(orders)} orders")
            print(f"Total progress: {len(all_orders)}/{total}")
            
            if len(all_orders) >= total:
                break
            
            page_no += 1
        else:
            print(f"Error: {response}")
            break
    
    print(f"\nTotal orders retrieved: {len(all_orders)}\n")
    
    # Categorize by operation type
    topups = [o for o in all_orders if o['operate_type'] == 'card_in']
    withdrawals = [o for o in all_orders if o['operate_type'] == 'card_out']
    
    # Calculate totals
    total_topup = sum(float(o['amount']) for o in topups)
    total_withdrawal = sum(float(o['amount']) for o in withdrawals)
    net_funding = total_topup - total_withdrawal
    
    print(f"Funding Summary:")
    print(f"  Top-ups: {len(topups)} orders, ${total_topup:,.2f}")
    print(f"  Withdrawals: {len(withdrawals)} orders, ${total_withdrawal:,.2f}")
    print(f"  Net Funding: ${net_funding:,.2f}")
    
    # Status breakdown
    success = len([o for o in all_orders if o['status'] == 'SUCCESS'])
    failed = len([o for o in all_orders if o['status'] == 'FAIL'])
    processing = len([o for o in all_orders if o['status'] == 'PROCESSING'])
    
    print(f"\nStatus Breakdown:")
    print(f"  Successful: {success}")
    print(f"  Failed: {failed}")
    print(f"  Processing: {processing}")
    
    return {
        'total': len(all_orders),
        'topups': topups,
        'withdrawals': withdrawals,
        'totals': {
            'topup': total_topup,
            'withdrawal': total_withdrawal,
            'net': net_funding
        },
        'all_orders': all_orders
    }

# Example usage
history = get_card_funding_history('card4777068445')

Track Specific Order Status

Check the status of a specific funding order:

async function trackFundingOrder(uniqueOrderId) {
  console.log(`\n=== Tracking Funding Order ===`);
  console.log(`Order ID: ${uniqueOrderId}\n`);
  
  try {
    const response = await queryCardFundingOrders({
      unique_order_id: uniqueOrderId
    });
    
    if (response.code === 'SUCCESS') {
      const orders = response.data.list;
      
      if (orders.length === 0) {
        console.log('❌ Order not found');
        return null;
      }
      
      const order = orders[0];
      const operation = order.operate_type === 'card_in' ? 'Top-up' : 'Withdrawal';
      
      console.log(`${operation} Order Details:`);
      console.log(`  Record ID: ${order.record_id}`);
      console.log(`  Your Order ID: ${order.unique_order_id}`);
      console.log(`  Amount: ${order.currency} ${order.amount}`);
      console.log(`  Card: ${order.card_number}`);
      console.log(`  Created: ${order.created}`);
      
      // Display status with appropriate emoji
      const statusEmoji = {
        'SUCCESS': '✅',
        'FAIL': '❌',
        'PROCESSING': '⏳'
      };
      
      console.log(`  Status: ${statusEmoji[order.status]} ${order.status}`);
      
      if (order.remark) {
        console.log(`  Note: ${order.remark}`);
      }
      
      // Provide status-specific guidance
      console.log('\nStatus Information:');
      if (order.status === 'SUCCESS') {
        console.log('  ✓ Funding operation completed successfully');
        console.log(`  ✓ ${operation} of ${order.currency} ${order.amount} has been processed`);
      } else if (order.status === 'FAIL') {
        console.log('  ✗ Funding operation failed');
        console.log('  • Please check with support for failure details');
        console.log('  • You may need to retry the operation');
      } else if (order.status === 'PROCESSING') {
        console.log('  ⏳ Funding operation is still processing');
        console.log('  • Please wait for the operation to complete');
        console.log('  • Check again in a few minutes');
      }
      
      return order;
    } else {
      console.log('❌ Failed to track order:', response);
      return null;
    }
  } catch (error) {
    console.error('Error tracking order:', error.message);
    return null;
  }
}

// Example usage
const order = await trackFundingOrder('ceda673a-62a0-4375-a55f-86d43ea89e9d');

Generate Monthly Funding Report

Create a comprehensive report of funding operations for a month:

def generate_monthly_funding_report(year, month):
    """
    Generate monthly funding report for all cards
    
    Args:
        year: Year (e.g., 2025)
        month: Month (1-12)
    """
    from datetime import datetime
    from calendar import monthrange
    
    # Calculate date range
    start_date = f"{year}-{month:02d}-01 00:00:00"
    last_day = monthrange(year, month)[1]
    end_date = f"{year}-{month:02d}-{last_day} 23:59:59"
    
    print(f"\n=== Monthly Funding Report ===")
    print(f"Period: {datetime(year, month, 1).strftime('%B %Y')}")
    print(f"Date Range: {start_date} to {end_date}\n")
    
    # Fetch all orders for the period
    all_orders = []
    page_no = 1
    
    while True:
        params = {
            "start_date": start_date,
            "end_date": end_date,
            "page_no": page_no,
            "page_size": 100
        }
        
        response = query_card_funding_orders(params)
        
        if response['code'] == 'SUCCESS':
            orders = response['data']['list']
            total = response['data']['total_num']
            
            all_orders.extend(orders)
            
            if len(all_orders) >= total:
                break
            
            page_no += 1
        else:
            break
    
    if not all_orders:
        print("No funding operations found for this period\n")
        return None
    
    # Analyze data
    topups = [o for o in all_orders if o['operate_type'] == 'card_in']
    withdrawals = [o for o in all_orders if o['operate_type'] == 'card_out']
    
    topup_success = [o for o in topups if o['status'] == 'SUCCESS']
    withdrawal_success = [o for o in withdrawals if o['status'] == 'SUCCESS']
    
    total_topup = sum(float(o['amount']) for o in topup_success)
    total_withdrawal = sum(float(o['amount']) for o in withdrawal_success)
    
    # Print report
    print("📊 Operation Summary")
    print("─" * 60)
    print(f"Total Operations: {len(all_orders)}")
    print(f"  Top-ups: {len(topups)} ({len(topup_success)} successful)")
    print(f"  Withdrawals: {len(withdrawals)} ({len(withdrawal_success)} successful)")
    
    print(f"\n💰 Financial Summary")
    print("─" * 60)
    print(f"Total Top-ups: ${total_topup:,.2f}")
    print(f"Total Withdrawals: ${total_withdrawal:,.2f}")
    print(f"Net Movement: ${(total_topup - total_withdrawal):,.2f}")
    
    # Status breakdown
    by_status = {}
    for order in all_orders:
        status = order['status']
        by_status[status] = by_status.get(status, 0) + 1
    
    print(f"\n📈 Status Breakdown")
    print("─" * 60)
    for status, count in by_status.items():
        percentage = (count / len(all_orders)) * 100
        print(f"{status.ljust(12)}: {count:3d} ({percentage:5.1f}%)")
    
    # Card-level breakdown
    by_card = {}
    for order in all_orders:
        card_id = order['card_id']
        if card_id not in by_card:
            by_card[card_id] = {
                'topups': 0,
                'withdrawals': 0,
                'topup_amount': 0,
                'withdrawal_amount': 0,
                'card_number': order['card_number']
            }
        
        if order['operate_type'] == 'card_in' and order['status'] == 'SUCCESS':
            by_card[card_id]['topups'] += 1
            by_card[card_id]['topup_amount'] += float(order['amount'])
        elif order['operate_type'] == 'card_out' and order['status'] == 'SUCCESS':
            by_card[card_id]['withdrawals'] += 1
            by_card[card_id]['withdrawal_amount'] += float(order['amount'])
    
    print(f"\n💳 Card-Level Activity")
    print("─" * 60)
    print(f"Active Cards: {len(by_card)}\n")
    
    for card_id, stats in sorted(by_card.items(), 
                                  key=lambda x: x[1]['topup_amount'] + x[1]['withdrawal_amount'],
                                  reverse=True)[:10]:
        print(f"Card: {stats['card_number']}")
        print(f"  Top-ups: {stats['topups']} orders, ${stats['topup_amount']:,.2f}")
        print(f"  Withdrawals: {stats['withdrawals']} orders, ${stats['withdrawal_amount']:,.2f}")
        print(f"  Net: ${(stats['topup_amount'] - stats['withdrawal_amount']):,.2f}\n")
    
    return {
        'period': f"{year}-{month:02d}",
        'total_orders': len(all_orders),
        'topups': len(topup_success),
        'withdrawals': len(withdrawal_success),
        'total_topup_amount': total_topup,
        'total_withdrawal_amount': total_withdrawal,
        'net_movement': total_topup - total_withdrawal,
        'by_card': by_card,
        'all_orders': all_orders
    }

# Example usage
report = generate_monthly_funding_report(2025, 1)

Monitor Failed Funding Orders

Identify and track failed funding operations:

async function monitorFailedOrders(startDate, endDate) {
  console.log('\n=== Failed Funding Orders Monitor ===\n');
  console.log(`Period: ${startDate} to ${endDate}\n`);
  
  try {
    const params = {
      status: 'FAIL',
      start_date: startDate,
      end_date: endDate,
      page_size: 100
    };
    
    let allFailedOrders = [];
    let pageNo = 1;
    
    while (true) {
      params.page_no = pageNo;
      
      const response = await queryCardFundingOrders(params);
      
      if (response.code === 'SUCCESS') {
        const orders = response.data.list;
        const total = response.data.total_num;
        
        allFailedOrders = allFailedOrders.concat(orders);
        
        if (allFailedOrders.length >= total) {
          break;
        }
        
        pageNo++;
      } else {
        break;
      }
    }
    
    if (allFailedOrders.length === 0) {
      console.log('✅ No failed orders found in this period\n');
      return {
        count: 0,
        orders: []
      };
    }
    
    console.log(`⚠️  Found ${allFailedOrders.length} failed order(s)\n`);
    
    // Categorize by operation type
    const failedTopups = allFailedOrders.filter(o => o.operate_type === 'card_in');
    const failedWithdrawals = allFailedOrders.filter(o => o.operate_type === 'card_out');
    
    console.log('Breakdown:');
    console.log(`  Failed Top-ups: ${failedTopups.length}`);
    console.log(`  Failed Withdrawals: ${failedWithdrawals.length}\n`);
    
    // Calculate potential impact
    const failedTopupAmount = failedTopups.reduce((sum, o) => sum + parseFloat(o.amount), 0);
    const failedWithdrawalAmount = failedWithdrawals.reduce((sum, o) => sum + parseFloat(o.amount), 0);
    
    console.log('Financial Impact:');
    console.log(`  Failed Top-up Amount: $${failedTopupAmount.toFixed(2)}`);
    console.log(`  Failed Withdrawal Amount: $${failedWithdrawalAmount.toFixed(2)}\n`);
    
    // List failed orders
    console.log('Failed Orders Details:\n');
    allFailedOrders.forEach((order, index) => {
      const operation = order.operate_type === 'card_in' ? 'TOP-UP' : 'WITHDRAWAL';
      console.log(`${index + 1}. ${operation} - ${order.currency} ${order.amount}`);
      console.log(`   Order ID: ${order.unique_order_id}`);
      console.log(`   Card: ${order.card_number}`);
      console.log(`   Created: ${order.created}`);
      if (order.remark) {
        console.log(`   Note: ${order.remark}`);
      }
      console.log();
    });
    
    // Recommendations
    console.log('📋 Recommendations:');
    console.log('  1. Review failed orders with support team');
    console.log('  2. Retry failed operations if appropriate');
    console.log('  3. Investigate common failure patterns');
    console.log('  4. Update processes to prevent future failures\n');
    
    return {
      count: allFailedOrders.length,
      topups: failedTopups,
      withdrawals: failedWithdrawals,
      total_amount: {
        topups: failedTopupAmount,
        withdrawals: failedWithdrawalAmount
      },
      orders: allFailedOrders
    };
  } catch (error) {
    console.error('Error monitoring failed orders:', error.message);
    return null;
  }
}

// Example usage
const failedOrders = await monitorFailedOrders(
  '2025-01-01 00:00:00',
  '2025-01-31 23:59:59'
);

Reconcile Funding Operations

Reconcile funding orders against your internal records:

def reconcile_funding_operations(your_orders, start_date, end_date):
    """
    Reconcile funding orders against your internal records
    
    Args:
        your_orders: List of your order IDs to reconcile
        start_date: Start date for query
        end_date: End date for query
    """
    print("\n=== Funding Operations Reconciliation ===\n")
    print(f"Period: {start_date} to {end_date}")
    print(f"Orders to reconcile: {len(your_orders)}\n")
    
    # Fetch all orders from the platform
    all_orders = []
    page_no = 1
    
    while True:
        params = {
            "start_date": start_date,
            "end_date": end_date,
            "page_no": page_no,
            "page_size": 100
        }
        
        response = query_card_funding_orders(params)
        
        if response['code'] == 'SUCCESS':
            orders = response['data']['list']
            total = response['data']['total_num']
            all_orders.extend(orders)
            
            if len(all_orders) >= total:
                break
            page_no += 1
        else:
            break
    
    # Create lookup dictionary
    platform_orders = {o['unique_order_id']: o for o in all_orders}
    
    # Reconciliation results
    matched = []
    missing = []
    status_mismatch = []
    amount_mismatch = []
    
    print("Processing reconciliation...\n")
    
    for your_order in your_orders:
        order_id = your_order['unique_order_id']
        
        if order_id not in platform_orders:
            missing.append(your_order)
            print(f"❌ MISSING: {order_id}")
            continue
        
        platform_order = platform_orders[order_id]
        
        # Check status match
        if your_order.get('expected_status') and \
           platform_order['status'] != your_order['expected_status']:
            status_mismatch.append({
                'order_id': order_id,
                'expected': your_order['expected_status'],
                'actual': platform_order['status'],
                'order': platform_order
            })
            print(f"⚠️  STATUS MISMATCH: {order_id}")
            print(f"   Expected: {your_order['expected_status']}, Got: {platform_order['status']}")
        
        # Check amount match
        if your_order.get('expected_amount'):
            expected_amt = float(your_order['expected_amount'])
            actual_amt = float(platform_order['amount'])
            
            if abs(expected_amt - actual_amt) > 0.01:  # Allow 1 cent difference
                amount_mismatch.append({
                    'order_id': order_id,
                    'expected': expected_amt,
                    'actual': actual_amt,
                    'difference': actual_amt - expected_amt,
                    'order': platform_order
                })
                print(f"⚠️  AMOUNT MISMATCH: {order_id}")
                print(f"   Expected: ${expected_amt:.2f}, Got: ${actual_amt:.2f}")
        
        if order_id not in [m['order_id'] for m in status_mismatch + amount_mismatch]:
            matched.append(platform_order)
            print(f"✓ MATCHED: {order_id}")
    
    # Summary
    print("\n" + "=" * 60)
    print("RECONCILIATION SUMMARY")
    print("=" * 60)
    print(f"Total Orders to Reconcile: {len(your_orders)}")
    print(f"✓ Matched: {len(matched)}")
    print(f"❌ Missing: {len(missing)}")
    print(f"⚠️  Status Mismatch: {len(status_mismatch)}")
    print(f"⚠️  Amount Mismatch: {len(amount_mismatch)}")
    
    success_rate = (len(matched) / len(your_orders) * 100) if your_orders else 0
    print(f"\nReconciliation Rate: {success_rate:.1f}%")
    
    if missing:
        print(f"\n❌ Missing Orders ({len(missing)}):")
        for order in missing:
            print(f"   • {order['unique_order_id']}")
    
    if status_mismatch:
        print(f"\n⚠️  Status Mismatches ({len(status_mismatch)}):")
        for mismatch in status_mismatch:
            print(f"   • {mismatch['order_id']}: Expected {mismatch['expected']}, Got {mismatch['actual']}")
    
    if amount_mismatch:
        print(f"\n⚠️  Amount Mismatches ({len(amount_mismatch)}):")
        for mismatch in amount_mismatch:
            print(f"   • {mismatch['order_id']}: Difference ${mismatch['difference']:.2f}")
    
    return {
        'matched': matched,
        'missing': missing,
        'status_mismatch': status_mismatch,
        'amount_mismatch': amount_mismatch,
        'success_rate': success_rate
    }

# Example usage
your_internal_orders = [
    {
        'unique_order_id': 'ceda673a-62a0-4375-a55f-86d43ea89e9d',
        'expected_status': 'SUCCESS',
        'expected_amount': '770.38'
    },
    {
        'unique_order_id': 'ceda673a-62a0-4375-a55f-86d43ea89e8d',
        'expected_status': 'SUCCESS',
        'expected_amount': '995.41'
    }
]

reconciliation = reconcile_funding_operations(
    your_internal_orders,
    '2025-01-01 00:00:00',
    '2025-12-31 23:59:59'
)

Export Funding Orders to CSV

Export funding data for external analysis:

def export_funding_orders_to_csv(start_date, end_date, filename='funding_orders.csv'):
    """
    Export all funding orders in date range to CSV
    
    Args:
        start_date: Start date (yyyy-MM-dd HH:mm:ss)
        end_date: End date (yyyy-MM-dd HH:mm:ss)
        filename: Output CSV filename
    """
    import csv
    
    print(f"Exporting funding orders to {filename}...")
    print(f"Period: {start_date} to {end_date}\n")
    
    # Fetch all orders
    all_orders = []
    page_no = 1
    
    while True:
        params = {
            "start_date": start_date,
            "end_date": end_date,
            "page_no": page_no,
            "page_size": 100
        }
        
        response = query_card_funding_orders(params)
        
        if response['code'] == 'SUCCESS':
            orders = response['data']['list']
            total = response['data']['total_num']
            all_orders.extend(orders)
            
            print(f"Fetched page {page_no}: {len(all_orders)}/{total} orders")
            
            if len(all_orders) >= total:
                break
            page_no += 1
        else:
            break
    
    if not all_orders:
        print("No orders to export\n")
        return None
    
    # Write to CSV
    fieldnames = [
        'record_id',
        'unique_order_id',
        'created',
        'operation_type',
        'amount',
        'currency',
        'card_id',
        'card_number',
        'status',
        'remark'
    ]
    
    with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        
        for order in all_orders:
            operation_type = 'Top-up' if order['operate_type'] == 'card_in' else 'Withdrawal'
            
            row = {
                'record_id': order['record_id'],
                'unique_order_id': order['unique_order_id'],
                'created': order['created'],
                'operation_type': operation_type,
                'amount': order['amount'],
                'currency': order['currency'],
                'card_id': order['card_id'],
                'card_number': order['card_number'],
                'status': order['status'],
                'remark': order.get('remark', '')
            }
            
            writer.writerow(row)
    
    print(f"\n✓ Successfully exported {len(all_orders)} orders to {filename}")
    
    return {
        'filename': filename,
        'count': len(all_orders),
        'orders': all_orders
    }

# Example usage
export_result = export_funding_orders_to_csv(
    '2025-01-01 00:00:00',
    '2025-12-31 23:59:59',
    'funding_orders_2025.csv'
)

Best Practices

• Reconciliation: Regularly reconcile funding orders against your internal records
• Order Tracking: Use unique_order_id for reliable order tracking
• Status Monitoring: Monitor PROCESSING orders and follow up if they stay too long
• Failed Orders: Investigate failed orders promptly and retry if needed
• Date Ranges: Use reasonable date ranges to avoid large result sets
• Pagination: Always implement pagination for production systems
• Audit Trail: Maintain audit logs of all funding operations

Understanding Operation Types

card_in (Top-up)

• Adds funds to a card
• Increases card balance
• Common for Dedicated Funds Cards
• Used for initial funding or refills

card_out (Withdrawal)

• Removes funds from a card
• Decreases card balance
• Common when closing cards or rebalancing
• Requires sufficient card balance

Understanding Order Status

SUCCESS

• Operation completed successfully
• Funds have been transferred
• Order is finalized

FAIL

• Operation failed
• Funds were not transferred
• May need investigation or retry

PROCESSING

• Operation is in progress
• Funds transfer pending
• Check again later for final status

Related Endpoints

• Top-up Card - Add funds to a card (creates card_in orders)
• Withdraw from Card - Remove funds (creates card_out orders)
• Query Card Details - View card information
• Query All Cards - List all cards

Troubleshooting

Order Not Found

• Cause: Invalid unique_order_id or order outside date range
• Solution:
  • Verify the order ID is correct
  • Expand date range if searching by date
  • Check if order was created successfully

PROCESSING Status Too Long

• Cause: Order stuck in processing state
• Solution:
  • Wait 5-10 minutes for standard processing
  • If still processing after 1 hour, contact support
  • Check for any system notifications

Failed Orders

• Cause: Various reasons (insufficient funds, card issues, etc.)
• Solution:
  • Check card status and balance
  • Verify operation parameters
  • Review error details with support
  • Retry with corrected parameters

Security Considerations

• Access Control: Restrict access to funding order queries
• Audit Logging: Log all funding order queries
• Data Privacy: Card numbers are masked but still handle carefully
• Reconciliation: Regular reconciliation prevents fraud
• Monitoring: Set up alerts for unusual funding patterns

Interactive API Explorer