> ## Documentation Index
> Fetch the complete documentation index at: https://docs.whitebit.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Crypto-as-a-Service integration

> How a CaaS integration is assembled from WhiteBIT's documented API building blocks.

export const RegionBaseUrl = ({className = "", showBaseUrl = true, protocol = "https"}) => {
  const {useState, useEffect, useRef} = React;
  const EU_ENABLED = false;
  const [region, setRegionState] = useState(() => {
    if (!EU_ENABLED) return "com";
    if (typeof window !== 'undefined') {
      return localStorage.getItem("api-region-preference") || "com";
    }
    return "com";
  });
  const [mounted, setMounted] = useState(false);
  const observerRef = useRef(null);
  const isSyncingRef = useRef(false);
  const updateAllContentOnPage = targetRegion => {
    try {
      const domainFrom = targetRegion === "eu" ? "whitebit.com" : "whitebit.eu";
      const domainTo = targetRegion === "eu" ? "whitebit.eu" : "whitebit.com";
      const links = document.querySelectorAll('a');
      links.forEach(link => {
        let href = link.getAttribute('href');
        if (href && href.includes(domainFrom)) {
          link.setAttribute('href', href.replace(domainFrom, domainTo));
        }
      });
      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
        acceptNode: node => {
          if (node.parentElement?.closest('.region-toggle-component')) {
            return NodeFilter.FILTER_REJECT;
          }
          return node.textContent.includes(domainFrom) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
        }
      });
      let currentNode;
      while (currentNode = walker.nextNode()) {
        currentNode.textContent = currentNode.textContent.replace(new RegExp(domainFrom, 'g'), domainTo);
      }
      console.log(`[RegionSync] Global content updated to ${domainTo}`);
    } catch (e) {
      console.error("[RegionSync] Error updating content:", e);
    }
  };
  const updateRegion = (newRegion, source) => {
    if (region === newRegion) return;
    console.log(`[RegionBaseUrl] Updating to "${newRegion}" (Source: ${source})`);
    if (source === 'observer') {
      isSyncingRef.current = true;
      setTimeout(() => isSyncingRef.current = false, 1000);
    }
    setRegionState(newRegion);
    localStorage.setItem("api-region-preference", newRegion);
    updateAllContentOnPage(newRegion);
    if (source === 'user-click') {
      window.dispatchEvent(new CustomEvent("regionChange", {
        detail: newRegion
      }));
      attemptToUpdateNativeDropdown(newRegion, 0);
      setTimeout(() => attemptToUpdateNativeDropdown(newRegion, 1), 500);
      setTimeout(() => attemptToUpdateNativeDropdown(newRegion, 2), 1500);
    }
  };
  const attemptToUpdateNativeDropdown = (targetRegion, attempt) => {
    if (isSyncingRef.current) return;
    try {
      const targetUrl = targetRegion === "eu" ? "https://whitebit.eu" : "https://whitebit.com";
      const targetDesc = targetRegion === "eu" ? "EU Server" : "Production Server";
      const selects = document.querySelectorAll('select');
      for (const select of selects) {
        if (select.innerHTML.includes('whitebit.com') || select.innerHTML.includes('whitebit.eu')) {
          select.value = targetUrl;
          select.dispatchEvent(new Event('change', {
            bubbles: true
          }));
          return;
        }
      }
      const buttons = Array.from(document.querySelectorAll('button, [role="combobox"]'));
      const serverSelector = buttons.find(btn => {
        if (btn.closest('a') || btn.closest('[class*="card"]') || btn.closest('nav')) {
          return false;
        }
        const txt = btn.textContent || "";
        const isServerDropdown = (txt.includes('Production Server') || txt.includes('EU Server') || txt.includes('WhiteBIT Global Server') || txt.includes('WhiteBIT EU Server')) && !txt.includes('Run') && !txt.includes('Send') || btn.getAttribute('role') === 'combobox';
        return isServerDropdown;
      });
      if (serverSelector) {
        const currentText = serverSelector.textContent || "";
        if (currentText.includes(targetDesc)) return;
        serverSelector.click();
        setTimeout(() => {
          const options = document.querySelectorAll('[role="option"], li, button');
          for (const opt of options) {
            const optText = opt.textContent || "";
            if (optText.includes(targetDesc) || optText.includes(targetUrl)) {
              opt.click();
              return;
            }
          }
        }, 100);
      }
    } catch (e) {
      console.error("[Sync] Error:", e);
    }
  };
  useEffect(() => {
    if (!EU_ENABLED) return;
    setMounted(true);
    updateAllContentOnPage(region);
    const handleStorageChange = e => {
      if (e.key === "api-region-preference" && e.newValue) {
        updateRegion(e.newValue, 'storage');
      }
    };
    const handleRegionChange = e => {
      if (e.detail !== region) {
        updateRegion(e.detail, 'event');
      }
    };
    window.addEventListener("storage", handleStorageChange);
    window.addEventListener("regionChange", handleRegionChange);
    observerRef.current = new MutationObserver(mutations => {
      if (isSyncingRef.current) return;
      updateAllContentOnPage(region);
      for (const mutation of mutations) {
        if (mutation.type !== 'childList' && mutation.type !== 'characterData') continue;
        const target = mutation.target;
        const el = target.nodeType === Node.TEXT_NODE ? target.parentElement : target;
        if (el && (el.getAttribute('role') === 'option' || el.closest('[role="listbox"]'))) continue;
        const text = target.textContent || "";
        if (text.includes('WhiteBIT EU Server') || text.includes('https://whitebit.eu') && text.includes('Server')) {
          if (el && el.tagName !== 'A' && !el.closest('.region-toggle-component')) {
            if (region !== 'eu') updateRegion('eu', 'observer');
          }
        } else if (text.includes('WhiteBIT Global Server') || text.includes('https://whitebit.com') && text.includes('Server')) {
          if (el && el.tagName !== 'A' && !el.closest('.region-toggle-component')) {
            if (region !== 'com') updateRegion('com', 'observer');
          }
        }
      }
    });
    observerRef.current.observe(document.body, {
      childList: true,
      subtree: true,
      characterData: true
    });
    if (typeof window !== 'undefined') {
      const current = localStorage.getItem("api-region-preference");
      if (current) attemptToUpdateNativeDropdown(current, 'init');
    }
    return () => {
      window.removeEventListener("storage", handleStorageChange);
      window.removeEventListener("regionChange", handleRegionChange);
      if (observerRef.current) observerRef.current.disconnect();
    };
  }, [region]);
  const apiBaseUrl = protocol === "wss" ? region === "eu" ? "wss://api.whitebit.eu/ws" : "wss://api.whitebit.com/ws" : region === "eu" ? "https://whitebit.eu" : "https://whitebit.com";
  const baseUrlLabel = protocol === "wss" ? "WebSocket URL" : "Base URL";
  if (!EU_ENABLED) {
    if (!showBaseUrl) return null;
    return <div className={`flex items-center gap-2 flex-wrap my-4 region-toggle-component ${className}`}>
                <span className="text-sm text-gray-500 dark:text-gray-400 font-mono">
                    {baseUrlLabel}
                </span>
                <span className="text-sm text-gray-400">:</span>
                {protocol === "wss" ? <code className="text-sm font-mono text-primary dark:text-primary-light">
                        {apiBaseUrl}
                    </code> : <a href={apiBaseUrl} target="_blank" rel="noopener noreferrer" className="text-sm font-mono text-primary dark:text-primary-light hover:underline">
                        {apiBaseUrl}
                    </a>}
            </div>;
  }
  if (!mounted) return null;
  return <div className={`flex items-center gap-2 flex-wrap my-4 region-toggle-component ${className}`}>
            <span className="text-sm text-gray-500 dark:text-gray-400 font-mono">
                {baseUrlLabel}
            </span>
            <span className="text-sm text-gray-400">(</span>
            <div className="inline-flex bg-gray-100 dark:bg-gray-800 rounded-lg p-0.5 border border-gray-200 dark:border-gray-700">
                <button onClick={() => updateRegion("com", "user-click")} className={`px-2 py-0.5 text-xs font-medium rounded-md transition-all ${region === "com" ? "bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 shadow-sm" : "text-gray-500 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-200"}`}>
                    .com
                </button>
                <button onClick={() => updateRegion("eu", "user-click")} className={`px-2 py-0.5 text-xs font-medium rounded-md transition-all ${region === "eu" ? "bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 shadow-sm" : "text-gray-500 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-200"}`}>
                    .eu
                </button>
            </div>
            <span className="text-sm text-gray-400">)</span>
            {showBaseUrl && <>
                    <span className="text-sm text-gray-400">:</span>
                    {protocol === "wss" ? <code className="text-sm font-mono text-primary dark:text-primary-light">
                            {apiBaseUrl}
                        </code> : <a href={apiBaseUrl} target="_blank" rel="noopener noreferrer" className="text-sm font-mono text-primary dark:text-primary-light hover:underline">
                            {apiBaseUrl}
                        </a>}
                </>}
        </div>;
};

<Note>
  **For developers.** This page routes each CaaS capability to the guide that documents it. For what
  CaaS is, the segments it fits, and the path to launch, see the
  [CaaS overview](/guides/caas-overview).
</Note>

A CaaS integration is assembled from the same documented API surface used across WhiteBIT's B2B
products. It does not restate the schemas — each linked guide carries the endpoint and field
detail.

<RegionBaseUrl />

## Prerequisites

* **A CaaS engagement scoped with WhiteBIT** — see the [CaaS overview](/guides/caas-overview) for what the model delivers and the path to launch.
* **Architecture alignment** — the instance, branding, and asset scope agreed during onboarding (see [Architecture alignment during onboarding](#architecture-alignment-during-onboarding)).
* **API access** — [HMAC-signed requests](/api-reference/authentication); each capability's endpoint and field detail lives in the linked product guide.

## Integration building blocks

### Core API access

* **REST and WebSocket.** 100+ authenticated REST endpoints and 14 public endpoints, plus WebSocket
  market data and private account streams. Requests are signed with HMAC-SHA512 using the
  `X-TXC-APIKEY`, `X-TXC-PAYLOAD`, and `X-TXC-SIGNATURE` headers. See
  [First API Call](/guides/first-api-call).
  [Order placement, modification, and cancellation](/websocket/order-management/overview) over the same
  connection arrive September 2, 2026 (global platform only), authorized once on the connection rather than
  per request.
* **SDKs and tooling.** Official Go, Python, and PHP SDKs, plus an MCP server and a CLI for
  AI-assisted integration. See [SDKs](/sdks) and [AI tools](/guides/use-with-ai).
* **API keys.** Two-factor authentication is required before key creation; the secret is shown only
  once at creation; up to 50 trusted IPs can be whitelisted per key; keys auto-deactivate after 14
  days of inactivity and are revoked on an account password change, block, or freeze. See
  [Authentication](/api-reference/authentication).
* **Rate limits.** Limits are set per scope and per endpoint. See
  [Rate limits](/api-reference/rate-limits) for current values rather than assuming a single figure.

<Warning>
  API keys grant account access. Restrict each key to the minimum scope and to known IPs, and store
  secrets outside application code. See [Authentication](/api-reference/authentication).
</Warning>

### Wallets and payments

* **Deposit addresses.** Generate a unique address per end user with
  `POST /api/v4/main-account/create-new-address`; incoming funds are reconciled by webhook. See the
  [Payment Integration guide](/guides/payment-integration) and the
  [Wallet-as-a-Service developer guide](/guides/waas-integration).
* **Withdrawals.** Fee-inclusive (`/withdraw`) and fee-on-top (`/withdraw-pay`) variants, plus
  withdrawal after conversion using the Convert service — request a quote, confirm at the quoted
  rate, then withdraw in the destination currency. See
  [Payment Integration](/guides/payment-integration) and [Convert](/platform/convert).
* **Fiat rails (EUR/SEPA).** Available after Phase 2 onboarding — API-generated deposit invoices and
  SEPA withdrawals. See the [On/Off-Ramp guide](/guides/on-off-ramp-integration).
* **WhiteBIT Codes.** Fee-free internal crypto transfers between WhiteBIT accounts, useful for
  settlement flows. See [WhiteBIT Codes](/platform/whitebit-codes).
* **Crypto Lending.** Fixed and Flex lending endpoints are restricted to B2B partners and require
  access to be granted through the
  [institutional services form](https://whitebit.com/institutional-services/b2b). See
  [Crypto Lending](/products/lending/overview).

Travel Rule affects deposits and withdrawals for EEA and Turkey accounts — the primary CaaS
segments (banks, EMIs, fintechs). The Travel Rule API for programmatic verification is enabled per
account via [institutional@whitebit.com](mailto:institutional@whitebit.com); see [Regulatory Compliance](/institutional/compliance).

For transfers in scope of the Travel Rule, originator and beneficiary information is required.
See [Travel Rule](/concepts/travel-rule) for the field requirements and the transfer flow.

### Account architecture

* **Sub-accounts.** Create and manage thousands of separate accounts under one umbrella, each with
  independent balances, API keys, and IP whitelists, with fee-free instant transfers between the
  main account and its sub-accounts. See [Sub-Accounts](/products/sub-accounts/overview).
* **Fast API Key via OAuth.** For flows where end users hold personal WhiteBIT accounts, a partner
  can issue user-scoped API keys through the OAuth API key flow. New partner integrations use this
  flow. See [Fast API Key via OAuth](/guides/fast-api-key-integration) and the
  [OAuth overview](/platform/oauth/overview).
* **Trading and conversion.** Spot markets across 800+ pairs, and the Convert service for instant
  conversion at a quoted rate without placing orders on the order book. See
  [Convert](/platform/convert).

<Note>
  The classic OAuth 2.0 Authorization Code Grant flow for direct account-data access is deprecated
  and will be removed on November 1, 2026. New integrations use the Fast API Key flow. See the
  [OAuth overview](/platform/oauth/overview).
</Note>

## Architecture alignment during onboarding

The public documentation covers the API surface, but not the full dedicated-instance model behind
CaaS. The items below define the integration architecture and are agreed and documented with
WhiteBIT during onboarding, before development starts.

* **Instance model** — how the dedicated, custom-branded instance relates to the public API
  surface, and which base URL and credentials the environment uses.
* **End-user account mapping** — how end customers map onto the WhiteBIT account model (for example,
  one sub-account per end user, versus a pooled account with the partner's own internal ledger), and
  the reconciliation and limit trade-offs of each.
* **KYC and KYB split** — which party verifies end customers, at which levels, and how verification
  status is exchanged between the partner and WhiteBIT.
* **Data residency and privacy** — where end-customer data is processed and stored, and the Data
  Processing Agreement (available via [compliance@whitebit.com](mailto:compliance@whitebit.com)).
* **Operational roles** — which staff hold which permissions (API key scopes, sub-account
  administration, withdrawal approval).
* **Support model** — support tiers, response targets, and incident channels beyond the public
  status page.
* **Fee and settlement terms.**

<Note>
  There is no public sandbox. Integrate against the live API with minimum amounts, run a limited
  pilot cohort, then scale to production. The [Go-Live Checklist](/best-practices/go-live-checklist)
  gates each stage.
</Note>

## Operating the integration

* **Webhooks.** Real-time notifications for deposits, withdrawals, code redemptions, and refunds,
  verified with an HMAC-SHA512 signature. Pair webhooks with periodic history polling as a
  reconciliation fallback. See [Webhooks](/platform/webhook).
* **Monitoring.** [status.whitebit.com](https://status.whitebit.com) reports platform, API, and blog
  status; [whitebit.com/system-page](https://whitebit.com/system-page) reports per-asset deposit,
  withdrawal, and transfer availability.
* **Testing.** WhiteBIT does not offer a public testnet. Test on the live API with minimum order
  sizes and low-minimum assets; Demo Tokens are available for risk-free spot practice.
* **Go-live.** Work through the [Go-Live Checklist](/best-practices/go-live-checklist) — covering
  authentication, error handling, rate limits, compliance, WebSocket, webhooks, monitoring, and
  testing.

## Support

* **Primary contact:** the assigned account manager, plus the support channels agreed during
  onboarding.
* **Programs and onboarding:** [institutional@whitebit.com](mailto:institutional@whitebit.com).
* **Compliance, VASP, and DPA:** [compliance@whitebit.com](mailto:compliance@whitebit.com).
* **Self-service:** [help.whitebit.com](https://help.whitebit.com) for platform questions;
  docs.whitebit.com for API documentation.

## What's next

<CardGroup cols={2}>
  <Card title="Overview" icon="layer-group" href="/guides/caas-overview">
    What CaaS is, who it is for, and the path to launch.
  </Card>

  <Card title="FAQ" icon="circle-question" href="/guides/caas-faq">
    Common questions on scope, onboarding, regions, and support.
  </Card>

  <Card title="Institutional Onboarding" icon="clipboard-check" href="/institutional/onboarding">
    KYB and the two-phase onboarding process.
  </Card>

  <Card title="Go-Live Checklist" icon="list-check" href="/best-practices/go-live-checklist">
    Pre-launch verification across every integration concern.
  </Card>
</CardGroup>