Bermuda Commercial Bank RESTful Open Banking API Implementation (v1)

Copy

• Copy for LLM

  Copy page as Markdown for LLMs
• View as Markdown

  Open this page as Markdown
• Open in ChatGPT

  Get insights from ChatGPT
• Open in Claude

  Get insights from Claude
• Connect to Cursor

  Install MCP server on Cursor
• Connect to VS Code

  Install MCP server on VS Code

{
  "virtualAccountNumber": "1000327642",
  "bicCode": "BPBKBMHMXXX",
  "accountHolderName": "T1 Project Alpha Escrow",
  "accountName": "New Title T2",
  "currency": "USD",
  "balance": {
    "amount": "0",
    "currency": "USD"
  },
  "category": "CMS Sub Acct"
}

async function createVirtualAccounts() {
  try {
    const response = await fetch('https://api.bcb.bm/v1/virtual-accounts', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type': 'application/json',
        'Accept': 'application/json',
        'Idempotency-Key': '123e4567-e89b-12d3-a456-426614174000' // Optional
      },
      body: JSON.stringify({
        callbackUrl: 'https://my-callback-url.com', // Optional
        // Optional: custom headers echoed in the completion webhook
        customHeaders: {
          'X-Custom-Header-1': 'CustomValue1',
          'X-Custom-Header-2': 'CustomValue2',
          'X-Custom-Header-3': 'CustomValue3'
        },
        items: [
          {
            currency: 'USD',
            accountHolderName: 'Test Company Ltd',
            accountName: 'Test Virtual Account 001',
            clientReference: 'BATCH-REF-001'
          },
          {
            currency: 'USD',
            accountHolderName: 'Test Company Ltd',
            accountName: 'Test Virtual Account 002',
            clientReference: 'BATCH-REF-002'
          }
        ]
      })
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`Virtual account creation failed: ${JSON.stringify(errorData)}`);
    }

    // Parse JSON response
    const batchResponse = await response.json();

    // Display batch job information
    console.log('Batch Job Created:');
    console.log(`  Job ID: ${batchResponse.jobId}`);
    console.log(`  Status: ${batchResponse.status}`);
    console.log(`  Status URL: ${batchResponse.statusUrl}`);
    console.log(`  Result URL: ${batchResponse.resultUrl}`);

    // Store these URLs for monitoring the job
    // Use statusUrl to check progress
    // Use resultUrl to get final outcomes

    return batchResponse;
  } catch (error) {
    console.error('Failed to create virtual accounts:', error.message);
    throw error;
  }
}

// Example usage:

// Create multiple virtual accounts
createVirtualAccounts();

async function getAllVirtualAccounts(currency = null, pageSize = 25) {
  try {
    // Build URL with optional parameters
    let url = 'https://api.bcb.bm/v1/virtual-accounts';
    const params = new URLSearchParams();
    
    if (currency) {
      params.append('currency', currency);
    }
    
    params.append('pageSize', pageSize.toString());
    params.append('pageStart', '0');
    
    url += '?' + params.toString();

    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`Virtual accounts retrieval failed: ${JSON.stringify(errorData)}`);
    }

    // Parse JSON response
    const result = await response.json();

    // Access pagination info
    const pagination = result.meta.pagination;
    console.log(`Page: ${pagination.page_start}, Size: ${pagination.page_size}, Total: ${pagination.total_size}`);

    // Process virtual accounts
    result.data.forEach((account, index) => {
      console.log(`Account ${index + 1}:`);
      console.log(`  Virtual Account Number: ${account.virtualAccountNumber}`);
      console.log(`  BIC: ${account.bicCode}`);
      console.log(`  Account Holder: ${account.accountHolderName}`);
      console.log(`  Account Name: ${account.accountName}`);
      console.log(`  Currency: ${account.currency}`);
      console.log(`  Balance: ${account.balance ? account.balance.amount + ' ' + account.balance.currency : 'N/A'}`);
      console.log(`  Category: ${account.category}`);
      
      if (account.clientReference) {
        console.log(`  Client Reference: ${account.clientReference}`);
      }
      
      if (account.effectiveDate) {
        console.log(`  Effective Date: ${account.effectiveDate}`);
      }
      
      if (account.createdAt) {
        console.log(`  Created At: ${account.createdAt}`);
      }
      
      // Log parent/settlement account relationships
      if (account.parentAccount) {
        console.log(`  Parent Account: ${account.parentAccount.accountNumber} (${account.parentAccount.accountName})`);
      }
      if (account.settlementAccount) {
        console.log(`  Settlement Account: ${account.settlementAccount.accountNumber} (${account.settlementAccount.accountName})`);
      }
      
      console.log('---');
    });

    return result;
  } catch (error) {
    console.error('Failed to retrieve virtual accounts:', error.message);
    throw error;
  }
}

// Example usage:

// Get all virtual accounts
getAllVirtualAccounts();

// Get only USD virtual accounts
getAllVirtualAccounts('USD');

// Get first 10 virtual accounts
getAllVirtualAccounts(null, 10);

async function updateVirtualAccount(virtualAccountNumber) {
  try {
    const response = await fetch(`https://api.bcb.bm/v1/virtual-accounts/${virtualAccountNumber}`, {
      method: 'PATCH',
      headers: {
        'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify({
        accountHolderName: 'Updated Project Alpha Escrow',
        accountName: 'Updated Project Alpha Virtual Account',
        clientReference: 'updated-reference-123'
      })
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`Virtual account update failed: ${JSON.stringify(errorData)}`);
    }

    // Parse JSON response
    const result = await response.json();
    const virtualAccount = result.data;
    
    // Log updated details
    console.log('Virtual Account Updated Successfully:');
    console.log(`  Account Number: ${virtualAccount.virtualAccountNumber}`);
    console.log(`  Account Holder: ${virtualAccount.accountHolderName}`);
    console.log(`  Account Name: ${virtualAccount.accountName}`);
    console.log(`  Currency: ${virtualAccount.currency}`);
    console.log(`  Category: ${virtualAccount.category}`);
    
    if (virtualAccount.balance) {
      console.log(`  Balance: ${virtualAccount.balance.amount} ${virtualAccount.balance.currency}`);
    }
    
    if (virtualAccount.clientReference) {
      console.log(`  Client Reference: ${virtualAccount.clientReference}`);
    }
    
    console.log(`  Effective Date: ${virtualAccount.effectiveDate}`);
    console.log(`  Created: ${virtualAccount.createdAt}`);
    
    // Log parent/settlement account info
    if (virtualAccount.parentAccount) {
      console.log(`  Parent Account: ${virtualAccount.parentAccount.accountNumber} (${virtualAccount.parentAccount.accountSubType})`);
    }
    if (virtualAccount.settlementAccount) {
      console.log(`  Settlement Account: ${virtualAccount.settlementAccount.accountNumber} (${virtualAccount.settlementAccount.accountSubType})`);
    }

    return result;
  } catch (err) {
    console.error('Error updating virtual account:', err);
    throw err;
  }
}

// Example usage:
updateVirtualAccount('1000327642');

async function getVirtualAccountDetails(accountNumber) {
  try {
    const url = `https://api.bcb.bm/v1/virtual-accounts/${encodeURIComponent(accountNumber)}`;

    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`Virtual account details retrieval failed: ${JSON.stringify(errorData)}`);
    }

    // Parse JSON response
    const result = await response.json();

    // Get the virtual account details (single object, not an array)
    const virtualAccount = result.data;
    console.log('Virtual Account Details:');
    console.log(`  Account Number: ${virtualAccount.virtualAccountNumber}`);
    console.log(`  BIC: ${virtualAccount.bicCode}`);
    console.log(`  Account Holder: ${virtualAccount.accountHolderName}`);
    console.log(`  Account Name: ${virtualAccount.accountName}`);
    console.log(`  Currency: ${virtualAccount.currency}`);
    console.log(`  Category: ${virtualAccount.category}`);
    
    if (virtualAccount.balance) {
      console.log(`  Balance: ${virtualAccount.balance.amount} ${virtualAccount.balance.currency}`);
    }
    
    console.log(`  Effective Date: ${virtualAccount.effectiveDate}`);
    console.log(`  Created: ${virtualAccount.createdAt}`);
    
    if (virtualAccount.clientReference) {
      console.log(`  Client Reference: ${virtualAccount.clientReference}`);
    }
    
    // Log parent account details
    if (virtualAccount.parentAccount) {
      console.log('  Parent Account:');
      console.log(`    Account Number: ${virtualAccount.parentAccount.accountNumber}`);
      console.log(`    Account ID: ${virtualAccount.parentAccount.accountId}`);
      console.log(`    CIF: ${virtualAccount.parentAccount.cif}`);
      console.log(`    Currency: ${virtualAccount.parentAccount.currency}`);
      console.log(`    Sub Type: ${virtualAccount.parentAccount.accountSubType}`);
      console.log(`    Status: ${virtualAccount.parentAccount.status}`);
      if (virtualAccount.parentAccount.availableBalance) {
        console.log(`    Available Balance: ${virtualAccount.parentAccount.availableBalance.amount} ${virtualAccount.parentAccount.availableBalance.currency}`);
      }
      if (virtualAccount.parentAccount.owners && virtualAccount.parentAccount.owners.length > 0) {
        console.log(`    Owner: ${virtualAccount.parentAccount.owners[0].displayName} (${virtualAccount.parentAccount.owners[0].accountHolderType})`);
      }
    }
    
    // Log settlement account details
    if (virtualAccount.settlementAccount) {
      console.log('  Settlement Account:');
      console.log(`    Account Number: ${virtualAccount.settlementAccount.accountNumber}`);
      console.log(`    Account ID: ${virtualAccount.settlementAccount.accountId}`);
      console.log(`    CIF: ${virtualAccount.settlementAccount.cif}`);
      console.log(`    Currency: ${virtualAccount.settlementAccount.currency}`);
      console.log(`    Sub Type: ${virtualAccount.settlementAccount.accountSubType}`);
      console.log(`    Status: ${virtualAccount.settlementAccount.status}`);
      if (virtualAccount.settlementAccount.availableBalance) {
        console.log(`    Available Balance: ${virtualAccount.settlementAccount.availableBalance.amount} ${virtualAccount.settlementAccount.availableBalance.currency}`);
      }
      if (virtualAccount.settlementAccount.owners && virtualAccount.settlementAccount.owners.length > 0) {
        console.log(`    Owner: ${virtualAccount.settlementAccount.owners[0].displayName} (${virtualAccount.settlementAccount.owners[0].accountHolderType})`);
      }
    }

    return result;
  } catch (error) {
    console.error('Failed to retrieve virtual account details:', error.message);
    throw error;
  }
}

// Example usage:

// Get details for a specific virtual account
getVirtualAccountDetails('1000326808');

// Get first page
async function getVirtualAccountTransactions(virtualAccountNumber, fromDate, toDate) {
  const url = new URL(`https://api.bcb.bm/v1/virtual-accounts/${encodeURIComponent(virtualAccountNumber)}/transactions`);
  url.searchParams.set('fromDate', fromDate);   // yyyy-MM-dd or yyyyMMdd
  url.searchParams.set('toDate', toDate);       // yyyy-MM-dd or yyyyMMdd
  url.searchParams.set('pageSize', '100');      // optional (first call only)

  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
      'Accept': 'application/json'
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to get VA transactions: ${error.message || 'Unknown error'}`);
  }

  const result = await response.json();
  // result.meta.pagination: { page_start, page_token, total_size, page_size }
  // result.data: Array of VA transactions
  // Example: inspect first item
  if (result.data?.length) {
    const t = result.data[0];
    console.log('Tx:', t.id, t.description, t.valueDate, t.value?.amount, t.value?.currency, t.debitAccountNumber?.number, t.creditAccountNumber?.number);
  }
  return result;
}

// Paginate through all pages
async function getAllVirtualAccountTransactions(virtualAccountNumber, fromDate, toDate) {
  let pageStart = 1;
  let pageToken = null;
  let totalPages = 0;
  const all = [];

  do {
    const url = new URL(`https://api.bcb.bm/v1/virtual-accounts/${encodeURIComponent(virtualAccountNumber)}/transactions`);
    url.searchParams.set('fromDate', fromDate);
    url.searchParams.set('toDate', toDate);
    if (pageStart === 1) {
      url.searchParams.set('pageSize', '100');   // first call only
    } else {
      url.searchParams.set('pageStart', String(pageStart));
      url.searchParams.set('pageToken', pageToken);
    }

    const res = await fetch(url.toString(), {
      headers: { 'Authorization': 'Bearer YOUR_ACCESS_TOKEN', 'Accept': 'application/json' }
    });
    if (!res.ok) throw new Error('Request failed');
    const body = await res.json();

    if (pageStart === 1) {
      const p = body.meta?.pagination;
      pageToken = p?.page_token;
      totalPages = Math.ceil((p?.total_size ?? 0) / (p?.page_size ?? 100));
      console.log('First page meta:', p);
    }

    if (Array.isArray(body.data)) all.push(...body.data);
    pageStart++;
  } while (pageStart <= totalPages);

  return all;
}

async function getVirtualAccountTransactionDetail(transactionId) {
  const url = `https://api.bcb.bm/v1/virtual-accounts/transactions/${encodeURIComponent(transactionId)}`;
  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
      'Accept': 'application/json'
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to get VA transaction detail: ${error.message || 'Unknown error'}`);
  }

  const result = await response.json();
  // result is a single transaction detail object
  console.log('Transaction ID:', result.id);
  console.log('Description:', result.description);
  console.log('Value Date:', result.valueDate);
  if (result.value) {
    console.log('Amount:', result.value.amount, result.value.currency);
  }
  return result;
}