Automated Bank Reconciliation API Made Effortless

Integrate powerful, automated reconciliation into your platform. Process thousands of transactions per second with perfect accuracy.

Lightning Fast

Our C++ processing engine handles millions of transactions in seconds. Built for enterprise-scale operations.

Perfect Accuracy

Advanced bidirectional matching algorithms ensure precise reconciliation with intelligent date and amount tolerance.

Simple Integration

RESTful API with JWT authentication. Straightforward CSV processing with customizable column mapping.

API Documentation

Step 1: Authentication

First, obtain a JWT token by authenticating with your ReconcileIQ credentials:

POST /api/login Authentication
{
  "email": "[email protected]",
  "password": "your-password"
}

The response will include a JWT token that you'll use in subsequent requests:

Response 200 OK
{
  "message": "Login successful.",
  "user": {
    "id": "user-uuid",
    "email": "[email protected]",
    "tier": "api_global"
  },
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

Step 2: Reconciliation Process

The reconciliation process happens in two steps:

2.1 Initial Request with CSV Data

POST / Requires Authorization
Headers:
{
  "Authorization": "Bearer your_jwt_token",
  "Content-Type": "application/json"
}

Body:
{
  "bankCsv": "base64_encoded_encrypted_csv",
  "bookCsv": "base64_encoded_encrypted_csv",
  "key": "encryption_key_base64",
  "clientId": "unique_client_identifier"
}

The server returns a mapping suggestion based on the CSV headers:

Response 200 OK
{
  "bank": {
    "headers": ["Date", "Description", "Debit", "Credit", "Balance"],
    "mapping": {
      "Date": {
        "columnIndex": 0,
        "columnName": "Date"
      },
      "Description": {
        "columnIndex": 1,
        "columnName": "Description"
      },
      "Money Out": {
        "columnIndex": 2,
        "columnName": "Debit"
      },
      "Money In": {
        "columnIndex": 3,
        "columnName": "Credit"
      }
    },
    "sampleRows": [
      ["2024-01-01", "Opening Balance", "", "1000.00", "1000.00"],
      ["2024-01-15", "Rent Payment", "500.00", "", "500.00"]
    ]
  },
  "book": {
    "headers": ["Transaction Date", "Narrative", "Amount", "Type"],
    "mapping": {
      "Date": {
        "columnIndex": 0,
        "columnName": "Transaction Date"
      },
      "Description": {
        "columnIndex": 1,
        "columnName": "Narrative"
      },
      "Single Amount": {
        "columnIndex": 2,
        "columnName": "Amount"
      }
    },
    "sampleRows": [
      ["2024-01-01", "Opening Balance", "1000.00", "Deposit"],
      ["2024-01-15", "Rent Payment", "-500.00", "Withdrawal"]
    ]
  }
}

2.2 Confirm Column Mapping

After reviewing the suggested mapping, confirm it to complete the reconciliation:

POST /api/reconciliation/approve-mapping Requires Authorization
Headers:
{
  "Authorization": "Bearer your_jwt_token",
  "Content-Type": "application/json"
}

Body:
{
  "clientId": "same_client_id_as_initial_request",
  "approvedMapping": {
    "bank": {
      "mapping": {
        "Date": {
          "columnIndex": 0,
          "columnName": "Date"
        },
        "Description": {
          "columnIndex": 1,
          "columnName": "Description"
        },
        "Money Out": {
          "columnIndex": 2,
          "columnName": "Debit"
        },
        "Money In": {
          "columnIndex": 3,
          "columnName": "Credit"
        }
      },
      "headers": ["Date", "Description", "Debit", "Credit", "Balance"]
    },
    "book": {
      "mapping": {
        "Date": {
          "columnIndex": 0,
          "columnName": "Transaction Date"
        },
        "Description": {
          "columnIndex": 1,
          "columnName": "Narrative"
        },
        "Single Amount": {
          "columnIndex": 2,
          "columnName": "Amount" 
        }
      },
      "headers": ["Transaction Date", "Narrative", "Amount", "Type"]
    }
  }
}

The server returns the reconciliation results:

Response 200 OK
{
  "missingFromBooks": [
    {
      "Date": "2024-02-15",
      "Amount": "105.99",
      "Description": "Supplier Payment"
    },
    {
      "Date": "2024-02-21",
      "Amount": "-32.50",
      "Description": "Refund Received"
    }
  ],
  "removeFromBooks": [
    {
      "Date": "2024-01-30",
      "Amount": "250.00",
      "Description": "Transfer to Savings"
    }
  ]
}

Data Encryption

For security, you must encrypt your CSV data before sending it to the API. Here's how:

JavaScript Example
// Generate encryption key
const generateKey = async () => {
  return await window.crypto.subtle.generateKey(
    {
      name: "AES-GCM",
      length: 256
    },
    true,
    ["encrypt", "decrypt"]
  );
};

// Encrypt CSV data
const encryptData = async (data, key) => {
  const iv = window.crypto.getRandomValues(new Uint8Array(12));
  const encoder = new TextEncoder();
  const encodedData = encoder.encode(data);

  const encryptedContent = await window.crypto.subtle.encrypt(
    {
      name: "AES-GCM",
      iv: iv
    },
    key,
    encodedData
  );

  const encryptedArray = new Uint8Array(iv.length + encryptedContent.byteLength);
  encryptedArray.set(iv);
  encryptedArray.set(new Uint8Array(encryptedContent), iv.length);

  return {
    encrypted: encryptedArray,
    key: await window.crypto.subtle.exportKey("raw", key)
  };
};

// Convert ArrayBuffer to Base64
const arrayBufferToBase64 = (buffer) => {
  const bytes = new Uint8Array(buffer);
  let binary = '';
  for (let i = 0; i < bytes.length; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  return btoa(binary);
};

// Usage
const processFiles = async (bankCsvContent, bookCsvContent) => {
  const key = await generateKey();
  const encryptedBank = await encryptData(bankCsvContent, key);
  const encryptedBook = await encryptData(bookCsvContent, key);
  
  const payload = {
    bankCsv: arrayBufferToBase64(encryptedBank.encrypted),
    bookCsv: arrayBufferToBase64(encryptedBook.encrypted),
    key: arrayBufferToBase64(encryptedBank.key),
    clientId: Date.now().toString(36) + Math.random().toString(36).substring(2)
  };
  
  // Now send this payload to the API
  // ...
};

Real-time Progress Updates

For large files, you can monitor progress using our WebSocket connection:

WebSocket Example
// Connect to WebSocket with client ID and token
const connectWebSocket = (clientId, token) => {
  const ws = new WebSocket(`wss://api.bankreconciler.app/ws?clientId=${clientId}&token=${token}`);
  
  ws.onopen = () => {
    console.log('WebSocket connected');
    // Send an initial ping
    ws.send(JSON.stringify({ type: 'ping' }));
  };
  
  ws.onmessage = (event) => {
    try {
      const data = JSON.parse(event.data);
      
      if (data.percentage !== undefined) {
        // Update progress UI
        updateProgressBar(data.percentage);
        updateProgressText(data.status || `Processing... ${Math.round(data.percentage)}%`);
      }
    } catch (err) {
      console.error('Failed to parse WebSocket message:', err);
    }
  };
  
  ws.onclose = () => {
    console.log('WebSocket connection closed');
  };
  
  return ws;
};

API Global Plans

Choose a plan that fits your reconciliation volume:

API Startup

£999 /month
  • 2.5M transactions/month
  • 99.9% uptime SLA
  • Integration support
Popular

API Growth

£2,499 /month
  • 10M transactions/month
  • 99.95% uptime SLA
  • Dedicated support

API Enterprise

Custom
  • Unlimited transactions
  • 99.99% uptime SLA
  • Dedicated account manager

Perfect For

Accounting Software

  • Add automated reconciliation to your platform
  • Save your users hours of manual work
  • Process millions of transactions monthly
  • Stand out from competitors

Perfect Integration Partners

  • Payment processors reconciling merchant accounts
  • ERP systems handling multiple entities
  • Banking and financial services platforms
  • Expense management and corporate card providers

Technical Advantages

High-Performance C++ Engine

Our core processing engine is written in C++ for ultimate speed. We use multi-threading to parallelize workloads and process thousands of transactions per second.

Enterprise-Grade Security

End-to-end encryption with AES-GCM. All data is encrypted client-side before transmission and JWT authentication protects all endpoints.

Intelligent Matching

Bidirectional matching with configurable date tolerance and fuzzy amount matching. Our algorithm handles date format variations and currency formatting automatically.

Smart CSV Parsing

Automatically detects column mappings and handles various CSV formats. Works with dozens of different bank formats and accounting systems.

Real-time Progress Updates

WebSocket integration provides real-time processing updates for large files. Keep your users informed during long-running operations.

Flexible Response Format

Clean JSON responses with transactions grouped logically. Easy to integrate into any UI or workflow.

Ready to Transform Your Reconciliation Process?

Contact our API team to discuss your integration needs and get started with a custom demo.

Request API Access

Frequently Asked Questions

How does the billing work for API usage?

Our API plans are billed monthly based on transaction volume. Each plan includes a set number of transactions per month, with overage charges applying if you exceed your limit. We measure transaction volume based on the total number of records processed across all reconciliation requests.

What file formats do you support?

Our API primarily supports CSV files for both bank statements and bookkeeping records. We can automatically detect column mappings for dozens of different bank formats and accounting systems. For other formats, you would need to convert them to CSV before sending to our API.

How does the API handle date formats?

Our system automatically detects common date formats including DD/MM/YYYY, MM/DD/YYYY, YYYY-MM-DD and many others. We use a sophisticated algorithm to identify the date format based on patterns in your data, and can even handle mixed formats in the same file.

Can I get a custom integration for my specific needs?

Yes! For enterprise clients, we offer custom integration services tailored to your specific requirements. This can include custom file format support, dedicated infrastructure, enhanced SLAs, and other specialized features. Contact our sales team to discuss your needs.

Is there a rate limit on API calls?

Standard API plans have rate limits to ensure service stability. These are typically 100 requests per minute, which is sufficient for most integration scenarios. Enterprise plans can have custom rate limits based on your needs.

How secure is the API?

We take security extremely seriously. All data is encrypted client-side before transmission using AES-GCM encryption. The API uses JWT authentication, and we don't store any of your financial data after processing. Our infrastructure complies with industry security standards, and we regularly perform security audits.