Sandbox
v7.10.0 Documentation — 56 Domains, 1,400+ Routes, GraphQL + REST + x402

Build with 1,400+ API Routes

REST, GraphQL, WebSocket, and CLI — integrate payments, lending, and compliance in minutes.

v7.10.0 Released: Solana wallet integration, Helius transaction monitoring, Alchemy webhook support, FCM push notifications. 56 DDD domains, 1,400+ API routes, GraphQL (45 domains), ISO 20022, ISO 8583, multi-rail payments, x402 Protocol.

Quick Start Guide

Get up and running with FinAegis in three simple steps

1

Clone Repository

Get the source code from GitHub

Terminal
$ git clone https://github.com/FinAegis/core-banking-prototype-laravel.git
$ cd core-banking-prototype-laravel
2

Install & Configure

Set up your development environment

Terminal
$ composer install
$ cp .env.example .env
$ php artisan key:generate
$ php artisan migrate
3

Start Building

Verify the API is running, then make your first request

cURL
# Verify the API is running (no auth needed)
$ curl http://localhost:8000/api/health
# {"status":"ok","version":"7.9.0"}
# Make an authenticated request
$ curl -H "Authorization: Bearer YOUR_API_KEY" \
http://localhost:8000/api/v2/accounts

API Overview

RESTful API built on modern standards with comprehensive documentation

Authentication

Secure API authentication using Bearer tokens. Get your API key from the dashboard after registration.

JavaScript
const headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
'Accept': 'application/json'
};
// Example API call
fetch('https://finaegis.org/api/v2/accounts', {
method: 'GET',
headers: headers
})
.then(response => response.json())
.then(data => console.log(data));

Rate Limiting

API requests are limited to ensure fair usage and platform stability.

Per Hour 1,000
Per Day 10,000
Burst Rate 100/min

Rate limit headers are included in all API responses for monitoring.

API Versioning

All endpoints are versioned (v1, v2) to ensure backward compatibility as we evolve the API.

Webhooks

Real-time event notifications for transactions, account updates, and system events.

Official SDKs

Native SDKs for JavaScript, Python, and PHP. Go and Ruby coming soon.

JavaScript Python PHP Go (soon) Ruby (soon)

Platform API Areas

Explore the full breadth of the FinAegis platform across 56 DDD domains

CrossChain

7 routes

Bridge protocols (Wormhole, LayerZero, Axelar), cross-chain swaps, fee comparison, and multi-chain portfolio tracking.

View endpoints →

DeFi

8 routes

DEX aggregation (Uniswap, Curve), lending (Aave), staking (Lido), yield optimization, flash loans, and portfolio management.

View endpoints →

RegTech

12 routes

MiFID II reporting, MiCA compliance, Travel Rule enforcement, jurisdiction adapters, and regulatory orchestration.

View endpoints →

Mobile Payment

25+ routes

Payment intents, receipts, activity feeds, receive addresses, P2P transfers, passkey auth, and biometric JWT.

View endpoints →

Partner / BaaS

24 routes

Banking-as-a-Service partner onboarding, SDK generation, white-label configuration, and tenant provisioning.

View endpoints →

AI Query

2 routes

Natural language transaction queries and AI-powered financial insights via the intelligent query interface.

View endpoints →

GraphQL API

45 domains

Schema-first GraphQL via Lighthouse PHP with queries, mutations, subscriptions, and DataLoaders across 45 domain schemas.

View endpoints →

Event Streaming

5 endpoints

Redis Streams-based event publishing, consumer groups, live metrics dashboard with projector lag and throughput monitoring.

View endpoints →

x402 Protocol

15+ endpoints

HTTP-native micropayments. Monetize APIs with USDC on Base. GraphQL + REST with AI agent payment support.

View endpoints →

ISO 20022

8 message types

Parse, generate, validate ISO 20022 messages. 8 message types (pacs, pain, camt) with REST + GraphQL APIs.

View endpoints →

Open Banking

PSD2 · AISP · PISP

PSD2 consent management, AISP account access, PISP payment initiation. Berlin Group and UK Open Banking adapters.

View endpoints →

Payment Rails

ACH · Fedwire · SEPA · RTP · FedNow

ACH, Fedwire, RTP, FedNow, SEPA with intelligent routing that selects the optimal rail automatically.

View endpoints →

Interledger

ILP · Open Payments · GNAP

ILP connections, Open Payments (GNAP authorization), and cross-currency quotes. Bridge fiat and crypto networks.

View endpoints →

Ledger

Double-entry accounting

Double-entry accounting, chart of accounts, journal entries, trial balance, and GL auto-posting with optional TigerBeetle driver.

View endpoints →

Microfinance

Group lending · IFRS · Teller ops

Group lending, IFRS loan provisioning, share accounts, teller operations, and savings products for inclusion banking.

View endpoints →

Explore payment features: x402 Protocol · Machine Payments · Zelta CLI

1,400+

API Routes

56

DDD Domains

3

SDKs Coming

MIT

Open Source

24/7

Support

Partner API Authentication

BaaS partners and third-party integrators use dedicated Partner API keys with scoped permissions

Partner API Keys

Partner keys provide scoped access to BaaS endpoints, tenant provisioning, SDK generation, and white-label configuration. Keys are issued during partner onboarding.

Key Prefix fpk_
Scopes baas, tenants, sdk, config
Rate Limit 5,000 req/hour
IP Whitelist Required

Partner Request Example

Include the Partner API key in the X-Partner-Key header alongside your standard Bearer token.

cURL
$ curl -X POST "https://finaegis.org/api/v2/partner/tenants" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "X-Partner-Key: fpk_your_partner_key" \
-H "Content-Type: application/json" \
-d '{"name": "Acme Bank", "plan": "enterprise"}'

Ready to Build?

Join our developer community and start building the future of finance

Code Examples

Real-world examples to get you started quickly

Create a New Account

Initialize a new bank account with initial deposit

JavaScript
const createAccount = async () => {
    const response = await fetch('https://finaegis.org/api/v2/accounts', {
        method: 'POST',
        headers: {
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            customer_id: 'cust_123456',
            currency: 'USD',
            initial_balance: 1000.00,
            account_type: 'checking'
        })
    });
    
    const account = await response.json();
    console.log('Account created:', account);
};

Transfer Funds

Execute a transfer between two accounts

Python
import requests

def transfer_funds(from_account, to_account, amount):
    url = "https://finaegis.org/api/v2/transfers"
    headers = {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }
    
    payload = {
        "from_account_id": from_account,
        "to_account_id": to_account,
        "amount": amount,
        "currency": "USD",
        "description": "Payment transfer"
    }
    
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# Execute transfer
result = transfer_funds("acc_123", "acc_456", 250.00)
print(f"Transfer ID: {result['transfer_id']}")

Exchange to GCU

Convert traditional currency to Global Currency Units

PHP
<?php
$api_key = 'YOUR_API_KEY';
$endpoint = 'https://finaegis.org/api/v2/gcu/exchange';

$data = [
    'from_currency' => 'USD',
    'amount' => 1000.00,
    'to_currency' => 'GCU'
];

$ch = curl_init($endpoint);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $api_key,
    'Content-Type: application/json'
]);

$response = curl_exec($ch);
$result = json_decode($response, true);

echo "You will receive: " . $result['gcu_amount'] . " GCU";
echo "Exchange rate: 1 USD = " . $result['rate'] . " GCU";

Handle Webhooks

Process real-time transaction notifications

Node.js
const express = require('express');
const crypto = require('crypto');

const app = express();
app.use(express.json());

app.post('/webhooks/zelta', (req, res) => {
    // Verify webhook signature
    const signature = req.headers['x-zelta-signature'];
    const payload = JSON.stringify(req.body);
    const secret = process.env.WEBHOOK_SECRET;
    
    const expectedSignature = crypto
        .createHmac('sha256', secret)
        .update(payload)
        .digest('hex');
    
    if (signature !== expectedSignature) {
        return res.status(401).send('Invalid signature');
    }
    
    // Process the webhook
    const { event, data } = req.body;
    
    switch (event) {
        case 'transaction.completed':
            console.log(`Transaction ${data.id} completed`);
            // Handle completed transaction
            break;
        case 'account.created':
            console.log(`New account created: ${data.account_id}`);
            // Handle new account
            break;
    }
    
    res.status(200).send('OK');
});