Production-Ready Atomic Transfer System

Atomic Multi-AccountTransfer System

Enterprise Atomic Transfer API built for developers. Multi-account transfers with SAGA pattern, half-success support, and zero-sum accounting. Perfect for credits, points, and digital assets with 99.99% uptime.

99.99% Uptime
SAGA Pattern
Auto Recovery
Zero-Sum Accounting

Start with our Transfer API - atomic multi-account operation:

Transfer API
POST /api/v1/transfer
{
"TransferId": "txn_001",
"UseHalfSuccess": true,
"FromAccounts": [{"AccountId": "user_123", "ItemType": "credits", "Amount": 100}],
"ToAccounts": [{"AccountId": "user_456", "ItemType": "credits", "Amount": 100}]
}
99.99%
Uptime SLA
<100ms
API Response
1M+
Credits Operations/Day
0
Data Loss

Built for Credits at Scale

Enterprise-grade distributed credits system with mathematical guarantees, automatic recovery, and battle-tested reliability patterns for digital credits management.

Official Account Isolation

Enterprise-Grade Security

Pre-defined official account ranges with negative balance support, isolated from user accounts for special business scenarios.

Perfect Zero-Sum Accounting

Zero Data Loss

Mathematical guarantee that all account balances sum to zero at any time, providing powerful self-checking mechanisms.

Hotspot Account Avoidance

High Concurrency

Dynamic distribution across official account ranges during transactions, effectively preventing hotspot account bottlenecks.

Semi-Success State Support

99.99% Uptime

Source account deduction completion marks semi-success, allowing target account additions to continue, significantly improving availability.

Sharding & Cross-Database

Infinite Scale

Built-in sharding capabilities supporting cross-database transactions, meeting large-scale business data storage requirements.

Automatic Recovery

Self-Healing

Self-checking and automatic progression features ensure eventual consistency, reducing manual intervention costs.

SAGA Pattern Implementation

Battle-Tested

Distributed transaction implementation based on SAGA pattern, ensuring data consistency across distributed environments.

Atomic Operations

ACID Compliant

Every transfer operation is atomic - either all succeed or all fail, with comprehensive rollback mechanisms.

SAGA Pattern Architecture

Built on proven distributed transaction patterns with comprehensive compensation mechanisms. Unlike traditional 2PC, our SAGA-based approach provides higher performance and lower resource locking costs.

Local Transaction + Compensation Transaction
Semi-Success State Management
Automatic Consistency Checking
1. Asset Deduction Phase
→ Execute source account deduction
2. Asset Addition Phase
→ Execute target account addition
3. State Management
→ Update transfer status
4. Compensation
→ Auto-rollback on failure

How XferAPI Credits Works

Four simple steps to implement atomic multi-account credits operations in your application. Built for developers, trusted by gaming and e-commerce platforms.

01

API Integration

Integrate XferAPI with a simple REST API call. Set your authentication token and start making transfer requests.

  • RESTful API with OpenAPI specification
  • SDKs available for major languages
  • Webhook support for real-time updates
02

Define Transfer Rules

Specify debit and credit accounts with amounts. Our system validates and ensures atomic execution.

  • Multi-account debit/credit operations
  • Business rule validation
  • Real-time balance checking
03

Atomic Execution

XferAPI executes the transfer using SAGA pattern with automatic rollback on any failure.

  • SAGA pattern with compensation
  • Semi-success state handling
  • Automatic retry mechanisms
04

Verification & Tracking

Get real-time status updates and comprehensive audit trails for every transfer operation.

  • Real-time status tracking
  • Comprehensive audit logs
  • Zero-sum balance verification

Perfect for Complex Business Scenarios

E-commerce Purchase

User purchases item, merchant receives payment, platform takes commission fee

User Credits → Merchant → Platform Fee
TransferScene: marketplace_purchase

Gaming Rewards

Player completes quest, earns rewards, system distributes from reward pool

Reward Pool → Player → Achievement Bonus
TransferScene: quest_completion

Group Buying

Multiple users join group buy, funds collected, seller receives payment

User A + User B + User C → Group Seller
TransferScene: group_purchase

Simple. Powerful. Reliable.

Get started in minutes with our intuitive Credits API and comprehensive SDKs. Battle-tested by gaming platforms and e-commerce sites worldwide.

REST API Call
curl -X POST https://api.xferapi.com/v1/transfer \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "TransferId": "txn_abc123",
    "UseHalfSuccess": true,
    "FromAccounts": [
      {
        "AccountId": "user_123",
        "ItemType": "credits",
        "Amount": 100,
        "ChangeType": "purchase",
        "Comment": "User purchase"
      }
    ],
    "ToAccounts": [
      {
        "AccountId": "user_456",
        "ItemType": "credits", 
        "Amount": 80,
        "ChangeType": "receive",
        "Comment": "Item sale"
      },
      {
        "AccountId": "platform_fee",
        "ItemType": "credits",
        "Amount": 20,
        "ChangeType": "commission",
        "Comment": "Platform fee"
      }
    ],
    "TransferScene": "marketplace_purchase",
    "Comment": "Digital item purchase with commission split"
  }'
Node.js SDK
const XferAPI = require('xferapi');
const client = new XferAPI('YOUR_API_KEY');

// Atomic multi-account transfer
const transferReq = {
  TransferId: 'txn_' + Date.now(),
  UseHalfSuccess: true,
  FromAccounts: [
    {
      AccountId: 'user_123',
      ItemType: 'credits',
      Amount: 100,
      ChangeType: 'purchase',
      Comment: 'User purchase'
    }
  ],
  ToAccounts: [
    {
      AccountId: 'user_456',
      ItemType: 'credits',
      Amount: 80,
      ChangeType: 'receive',
      Comment: 'Item sale'
    },
    {
      AccountId: 'platform_fee', 
      ItemType: 'credits',
      Amount: 20,
      ChangeType: 'commission',
      Comment: 'Platform fee'
    }
  ],
  TransferScene: 'marketplace_purchase',
  Comment: 'Digital item purchase'
};

const error = await client.transfer(transferReq);
if (!error) {
  console.log('Transfer completed successfully');
} else {
  console.error('Transfer failed:', error);
}
Python SDK
import xferapi
import time

client = xferapi.Client('YOUR_API_KEY')

# Create atomic transfer request
transfer_req = {
    'TransferId': f'txn_{int(time.time())}',
    'UseHalfSuccess': True,
    'FromAccounts': [
        {
            'AccountId': 'user_123',
            'ItemType': 'credits',
            'Amount': 100,
            'ChangeType': 'purchase',
            'Comment': 'User purchase'
        }
    ],
    'ToAccounts': [
        {
            'AccountId': 'user_456',
            'ItemType': 'credits', 
            'Amount': 80,
            'ChangeType': 'receive',
            'Comment': 'Item sale'
        },
        {
            'AccountId': 'platform_fee',
            'ItemType': 'credits',
            'Amount': 20,
            'ChangeType': 'commission', 
            'Comment': 'Platform fee'
        }
    ],
    'TransferScene': 'marketplace_purchase',
    'Comment': 'Digital item purchase with commission'
}

error = client.transfer(transfer_req)
if not error:
    print('Transfer completed successfully')
else:
    print(f'Transfer failed: {error}')

Response

// Success Response
{
  "error": null
}

// Error Response  
{
  "error": {
    "code": "InsufficientAmountErr",
    "message": "Account user_123 has insufficient balance",
    "details": {
      "AccountId": "user_123",
      "RequiredAmount": 100,
      "CurrentBalance": 50
    }
  }
}
<1s

Lightning Fast

Average response time under 100ms for all credits operations.

100%

Atomic Guarantee

Every credits operation is atomic - all succeed or all fail.

∞

Infinite Scale

Built-in sharding and cross-database transaction support.

Core API Interfaces

Three essential APIs providing complete atomic transfer, rollback, and automatic inspection capabilities

Transfer API

Atomic multi-account transfer operations with half-success support

TransferId: Unique transfer identifier
UseHalfSuccess: Half-success state support
FromAccounts/ToAccounts: Multi-account operations
ItemType: Support for multiple asset types
ChangeType: Detailed change type recording
TransferScene: Business scenario identifier

Rollback API

Safely rollback executed transfer operations

TransferId: Specify transfer to rollback
TransferScene: Scenario validation
Automatic state checking
Compensation transaction execution
Data consistency guarantee
Operation audit recording

Inspection API

Automatically check and advance half-success state transfers

lastTime: Batch checking by timestamp
Automatic state advancement
Exception transfer rollback
Batch error processing
System self-healing capability
Scheduled task support

Best Practices

Uniqueness Guarantee

Ensure transfer_id and transfer_scene combination is unique across different transfers

Transaction Isolation

Recommended database transaction isolation level: READ-COMMITTED

Regular Inspection

Set up scheduled tasks to execute Inspection API for processing half-success transfers

Exception Monitoring

Monitor system errors and half-success states for timely problem detection

Common Error Codes

InsufficientAmountErr

Account balance is insufficient, please check if source account has enough balance

Solution: Verify account balance or adjust transfer amount

AlreadyRolledBackErr

Transfer has already been rolled back, cannot execute new operations

Solution: Check transfer status and avoid duplicate operations

StateMutationErr

State mutation error, possibly caused by concurrent operations

Solution: Implement business-side queuing to avoid concurrency conflicts

Trusted by Industry Leaders

From fintech startups to enterprise gaming platforms, XferAPI powers mission-critical transfer operations for companies worldwide.

500+
Companies Trust XferAPI
From startups to Fortune 500
99.99%
Uptime Achieved
Industry-leading reliability
1B+
Transfers Processed
Handling critical transactions
0
Data Loss Events
Zero-sum guarantees work

"XferAPI solved our multi-party payment splitting nightmare. The zero-sum accounting gives us complete confidence in our financial reconciliation. Setup took less than an hour."

SC
Sarah Chen
CTO, PayFlow Inc

"We process millions of gaming credit transfers daily. XferAPI's hotspot avoidance and automatic recovery mechanisms have been game-changers for our uptime."

MR
Marcus Rodriguez
Lead Architect, GameCorp

"The SAGA pattern implementation is brilliant. We've eliminated data inconsistencies completely while maintaining high performance. Best investment we've made."

DEW
Dr. Emma Watson
Head of Engineering, FinTech Solutions

Trusted by companies of all sizes

FinTech Co
GameCorp
PayFlow
TechStart
Enterprise

Ready to Build Something Amazing?

Join thousands of developers who trust XferAPI for their mission-critical transfer operations. Start building in minutes with our comprehensive documentation and SDKs.

Quick Setup

Get up and running in under 5 minutes with our intuitive API and comprehensive guides.

Enterprise Ready

Battle-tested reliability with 99.99% uptime SLA and comprehensive audit trails.

Developer First

Built by developers, for developers. Clean APIs, great docs, and responsive support.

500+
Companies
1B+
Transfers
99.99%
Uptime
Trusted by startups and enterprises worldwide

Have questions? We're here to help.

contact@xferapi.combiz@xferapi.com (Business)