Introduction

If you're building a marketplace, edtech platform, or any product where money arrives from many sources and must land in the right ledger row, you need virtual accounts — unique bank details per user, merchant, student, or patient so reconciliation is automatic.

This tutorial walks through creating virtual bank accounts with Anchor in sandbox: customer creation, account provisioning, balance checks, and transaction history. The code is TypeScript; patterns apply to any HTTP client.

Use case: A multi-vendor marketplace assigns each seller a dedicated collection account. When a buyer pays, funds hit that seller's virtual account — no manual matching against a single shared pool.

Note: Verify exact endpoint paths, product names, and attribute fields against docs.getanchor.co before production. APIs evolve; this article reflects the JSON:API resource pattern used across Anchor.

Prerequisites

Anchor sandbox account and API key
Node.js 18+ (for native fetch) or your preferred HTTP client
Basic familiarity with REST and JSON

ANCHOR_SANDBOX_KEY=your_key_here
ANCHOR_BASE_URL=https://api.sandbox.getanchor.co

Architecture: marketplace collection flow

Buyer pays → Virtual NUBAN / collection account (per merchant)
                    ↓
            Webhook: payment.received (Week 4 topic)
                    ↓
            Your DB: credit merchant ledger
                    ↓
            Bulk transfer → merchant bank (settlement)

Step 1 — Create a customer

Every account is tied to a Customer resource. For a marketplace, one customer per merchant (or per business entity).

TypeScript

const ANCHOR_KEY = process.env.ANCHOR_SANDBOX_KEY!;
const BASE_URL = process.env.ANCHOR_BASE_URL ?? "https://api.sandbox.getanchor.co";

interface AnchorResponse<T> {
  data: T;
}

interface Customer {
  id: string;
  type: "Customer";
  attributes: Record<string, unknown>;
}

async function createCustomer(input: {
  fullName: string;
  email: string;
}): Promise<string> {
  const res = await fetch(`${BASE_URL}/api/v1/customers`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-anchor-key": ANCHOR_KEY,
    },
    body: JSON.stringify({
      data: {
        type: "Customer",
        attributes: {
          fullName: input.fullName,
          email: input.email,
        },
      },
    }),
  });

  if (!res.ok) {
    const err = await res.text();
    throw new Error(`Create customer failed (${res.status}): ${err}`);
  }

  const json = (await res.json()) as AnchorResponse<Customer>;
  return json.data.id;
}

cURL

curl --request POST \
  --url "$ANCHOR_BASE_URL/api/v1/customers" \
  --header "Content-Type: application/json" \
  --header "x-anchor-key: $ANCHOR_SANDBOX_KEY" \
  --data '{
    "data": {
      "type": "Customer",
      "attributes": {
        "fullName": "Acme Merchant Ltd",
        "email": "merchant@example.com"
      }
    }
  }'

Save the returned data.id as customerId.

Step 2 — Create a deposit / virtual collection account

Anchor exposes account products via the accounts API. For collections, you typically create a DepositAccount (or the virtual-account product name specified in your dashboard/docs).

Link the account to the customer through relationships.

TypeScript

interface DepositAccount {
  id: string;
  type: "DepositAccount";
  attributes: {
    productName?: string;
    accountNumber?: string;
    [key: string]: unknown;
  };
}

async function createDepositAccount(customerId: string): Promise<DepositAccount> {
  const res = await fetch(`${BASE_URL}/api/v1/accounts`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-anchor-key": ANCHOR_KEY,
    },
    body: JSON.stringify({
      data: {
        type: "DepositAccount",
        attributes: {
          productName: "CURRENT", // confirm product enum in docs
        },
        relationships: {
          customer: {
            data: { type: "Customer", id: customerId },
          },
        },
      },
    }),
  });

  if (!res.ok) {
    const err = await res.text();
    throw new Error(`Create account failed (${res.status}): ${err}`);
  }

  const json = (await res.json()) as AnchorResponse<DepositAccount>;
  return json.data;
}

cURL

curl --request POST \
  --url "$ANCHOR_BASE_URL/api/v1/accounts" \
  --header "Content-Type: application/json" \
  --header "x-anchor-key: $ANCHOR_SANDBOX_KEY" \
  --data '{
    "data": {
      "type": "DepositAccount",
      "attributes": {
        "productName": "CURRENT"
      },
      "relationships": {
        "customer": {
          "data": { "type": "Customer", "id": "CUSTOMER_ID_HERE" }
        }
      }
    }
  }'

Marketplace tip: Store accountId and any account number / NUBAN returned in attributes against your merchants table. Display collection details to the seller in your dashboard.

Step 3 — Fetch balance

Confirm the balance endpoint path in docs — pattern is typically account-scoped.

TypeScript

async function getAccountBalance(accountId: string): Promise<unknown> {
  const res = await fetch(
    `${BASE_URL}/api/v1/accounts/${accountId}/balance`,
    {
      headers: { "x-anchor-key": ANCHOR_KEY },
    }
  );

  if (!res.ok) {
    throw new Error(`Balance fetch failed (${res.status})`);
  }

  return res.json();
}

cURL

curl --request GET \
  --url "$ANCHOR_BASE_URL/api/v1/accounts/ACCOUNT_ID_HERE/balance" \
  --header "x-anchor-key: $ANCHOR_SANDBOX_KEY"

Sandbox may return zero until you simulate or receive test inflows — that's expected.

Step 4 — List transactions

Use transaction listing to verify inflows during integration and to power merchant statements in your app.

TypeScript

async function listTransactions(accountId: string): Promise<unknown> {
  const res = await fetch(
    `${BASE_URL}/api/v1/accounts/${accountId}/transactions`,
    {
      headers: { "x-anchor-key": ANCHOR_KEY },
    }
  );

  if (!res.ok) {
    throw new Error(`Transactions fetch failed (${res.status})`);
  }

  return res.json();
}

cURL

curl --request GET \
  --url "$ANCHOR_BASE_URL/api/v1/accounts/ACCOUNT_ID_HERE/transactions" \
  --header "x-anchor-key: $ANCHOR_SANDBOX_KEY"

Step 5 — Put it together

async function onboardMarketplaceMerchant(merchant: {
  name: string;
  email: string;
}) {
  const customerId = await createCustomer({
    fullName: merchant.name,
    email: merchant.email,
  });

  const account = await createDepositAccount(customerId);
  const balance = await getAccountBalance(account.id);

  return {
    customerId,
    accountId: account.id,
    collectionDetails: account.attributes,
    balance,
  };
}

Run once in sandbox. Log responses. Map errors to user-facing copy before production.

Other use cases (same API pattern)

Vertical	Virtual account per…	Payoff
Edtech	Student / enrollment	Automatic fee reconciliation
Healthtech	Patient	Match payment to record
PropTech	Tenant / property	Rent collection without manual matching
Event tech	Event or organiser	Revenue attribution

See the full vertical library: Anchor use cases for gig, payroll, insurtech, and more.

Production checklist

Complete KYC requirements for your customer type
Webhook handler for inbound payment events (don't poll forever)
Idempotency keys on account creation if your API retries
Encrypt API keys; rotate on leak
Reconciliation job: provider events ↔ your ledger

Resources

Disclosure: I partner with Anchor as Developer Tech Evangelist. Code patterns here reflect my sandbox integration; always verify against current documentation.