For the complete documentation index, see llms.txt. This page is also available as Markdown.

Accounts Quick Start Guide

This article walks through the entire customer experience with XYB's Accounts capabilities—from setup to production. It includes touchpoints across the hosted developer environment, APIs, and the configuration console.


1. Starting Point: Access to the Platform

As a customer of XYB:

  • You are onboarded into a hosted developer environment, with secure access to:

    • API credentials and sandbox URLs

    • A web console for product configuration

You receive a fully isolated instance with the capability to configure and simulate the full account lifecycle.


2. Product Configuration (via Console)

What happens:

You define account products through the Product Configuration Console.

Key actions:

  • Create account product definitions (e.g., "Retail GBP Account", "FX Wallet")

  • Assign:

    • Default currency

    • Supported jurisdictions

    • Initial state

    • Optional flags like "silent statement push"

  • Link accounts to services (e.g., balance management, account rules)

Interface used:

  • Products tab in the Console: define names, references, descriptions.

  • Services tab: attach service behavior (e.g., wallet rules, lifecycle rules).

  • Schema Builder: customize metadata, tags, or compliance rules.

Outcome: This product becomes the template for account creation via API or UI.


3. API Integration: Account Lifecycle

After configuration, you begin integrating with XYB’s Accounts APIs.

Use cases:

  • Create new accounts

  • Fetch accounts by ID or owner

  • Attach banking coordinates (like IBANs)

  • Query live balances or statements

Typical flow:

Step
API Action
Description

1

POST /account

Create a new account for a user using a configured product

2

GET /account/{id}

Retrieve full account details

3

PATCH /account/{id}/attributes

Add metadata like tax tags, product overrides

4

POST /account/{id}/coordinates

Attach internal or banking coordinates

5

GET /account/{id}/wallets

Fetch real-time balances

6

POST /account/{id}/state

Change state (e.g. block, close) with audit trail


4. Real-Time Monitoring & Testing

As a developer or product owner:

  • You test your integration in XYB's sandbox environment.

  • Use tools like:

    • Query explorer in the Console

    • Transaction simulators

    • Schema validation checks

  • API responses include:

    • Account UUIDs

    • Wallet balance snapshots

    • Audit logs and timestamps

You can simulate full flows like account blocking, attribute changes, or balance sweeping via test hooks.


5. Account States, Rules & Governance

Accounts support a comprehensive lifecycle:

State
Use case

PENDING

Initial creation

OPEN

Account is usable

SUSPENDED_IN/OUT

Temporarily frozen for incoming or outgoing funds

BLOCKED

Restricted due to compliance or fraud

CLOSED / TERMINATED

Final state after deactivation

You define rules and status transitions in the Console (e.g., “when UNDERAGE, map to SUSPENDED”).

All transitions are API-triggered and audited. Some require approval workflows if configured.


6. Advanced Features: Wallets & Sweeping

Every account has:

  • One or more wallets (currency-specific balance holders)

  • Support for:

    • Live balances (/wallets)

    • Global consolidated balances (/wallets/gcb)

    • Sweeping rules to automate fund movement across wallets

Customers can:

  • Configure rules for wallet prioritization (e.g., auto-drain secondary balances)

  • View balance composition via wallet APIs

  • Manage sweeping via APIs or backend logic


7. Moving to Production

Once tested:

  • You switch to live environment endpoints

  • XYB enables:

    • Access control and role-based permissioning

    • Secure certificate handling for production

    • Rate limits, SLAs, and logging

All product configurations carry over—no need to redefine products.


Summary: End-to-End Experience

Stage
Customer Touchpoint
Purpose

Kickoff

Hosted developer environment

Get started with sandbox access

Configuration

Product Console

Define account types and behaviors

Integration

API Suite

Programmatically create and manage accounts

Testing

Sandbox + Query tools

Validate flows and simulate edge cases

Advanced

Wallets, sweeping, attributes

Add financial logic and operational metadata

Production

Live switch + access control

Move to real-world usage with stability

Last updated