> ## 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.

# Integration Paths

> Find the recommended integration path for each partner type — market makers, brokers, algo traders, payment providers, prop trading firms, and institutional clients.

export const RegionBaseUrl = ({className = "", showBaseUrl = true}) => {
  const [region, setRegionState] = useState(() => {
    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(() => {
    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 = region === "eu" ? "https://whitebit.eu" : "https://whitebit.com";
  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">
                Base URL
            </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>
                    <a href={apiBaseUrl} target="_blank" rel="noopener noreferrer" className="text-sm font-mono text-primary dark:text-primary-light hover:underline">
                        {apiBaseUrl}
                    </a>
                </>}
        </div>;
};

<RegionBaseUrl />

WhiteBIT supports six partner types: market makers, brokers, algo traders, payment providers, prop trading firms, and institutional clients. Each section lists the program terms, the relevant endpoints, and the next guide to read.

## Market makers

Professional market-making firms benefit from the [Market-Making Program](https://institutional.whitebit.com/market-making-program), which offers maker rebates up to -0.012%, [colocation](/platform/colocation) infrastructure, and [bulk order](/api-reference/spot-trading/bulk-limit-order) capabilities (up to 20 orders per call). The program includes a dedicated account manager and cross-marketing support.

For the complete integration walkthrough, see the [Market Maker Guide](/guides/market-maker-guide).

## Brokers and trading platforms

Brokers and trading platforms integrate via the [Broker Program](https://institutional.whitebit.com/broker-program), offering WhiteBIT liquidity to end users through a [sub-account](/products/sub-accounts/overview) architecture. The program provides up to 40% fee share on trading fees generated by referred users, per-customer account isolation, and per-customer API keys.

Brokers that need to issue per-customer API keys via OAuth (alongside or instead of the sub-account model) can use the [Fast API Key via OAuth](/guides/fast-api-key-via-oauth) flow to bootstrap keys on behalf of users without manual copy-paste.

For the complete integration walkthrough, see the [Broker Guide](/guides/broker-guide).

## Algo trading and bot providers

Algorithmic trading systems and trading bots integrate through a combination of REST API for order management and WebSocket for real-time market data.

Start with the [First API Call](/guides/first-api-call) guide to verify connectivity and authentication. Then proceed to the [Market Data Quickstart](/products/market-data/quickstart) for real-time price feeds, the [Spot Trading Quickstart](/products/spot/quickstart) for order placement, and the [Trading Bot](/guides/building-a-trading-bot) guide for a complete automated trading workflow. The [WebSocket Quickstart](/guides/websocket-quickstart) covers real-time data streaming.

**Key technical considerations:**

* [Rate limits](/api-reference/rate-limits): polling frequency must stay within per-endpoint limits; WebSocket streaming is recommended for real-time data to reduce REST polling
* [Kill-switch](/api-reference/spot-trading/kill-switch): emergency mechanism to cancel all open orders after a configurable timeout — critical safety feature for unattended bots
* [Order Types](/concepts/order-types): Market, Limit, Stop-Limit, Stop-Market, Stock-Market, and Bulk-Limit — availability varies by market type
* [Client Order ID](/guides/client-order-id): attach custom identifiers to orders for tracking across systems

**Infrastructure recommendations:**

* Use [sub-accounts](/products/sub-accounts/overview) for strategy separation when running multiple bots
* Consider [colocation](/platform/colocation) for latency-sensitive strategies
* Implement the [kill-switch](/api-reference/spot-trading/kill-switch) as a circuit breaker for all production bots
* Set up [Account Monitoring](/guides/account-monitoring) for balance tracking, deposit/withdrawal alerts, and order activity monitoring

<Note>
  WhiteBIT does not offer a public testnet. Test all trading flows on the live API with minimum order amounts. Use `GET /api/v4/public/markets` to find pairs with the lowest minimum order sizes for testing.
</Note>

## Payment and ramp providers

Payment providers and on/off-ramp services integrate deposit and withdrawal workflows to move funds programmatically.

Start with the [First API Call](/guides/first-api-call) guide for authentication setup. Then proceed to the [Payment Integration](/guides/payment-integration) guide for the complete deposit/withdrawal lifecycle, fee calculation, and status state machines. Review [Webhooks](/platform/webhook) for real-time transaction notifications and [Regulatory Compliance](/institutional/compliance) for EEA-specific requirements.

Payment and ramp providers that issue API keys on behalf of merchants can bootstrap keys through the [Fast API Key via OAuth](/guides/fast-api-key-via-oauth) flow as an alternative to manual key generation.

**Key considerations:**

* [Travel Rule](/institutional/compliance): EEA crypto withdrawals require a `travelRule` object with beneficiary information
* MiCA compliance: USDT operations are restricted for EEA users since December 30, 2024 — use USDC or EURI as alternatives
* [Webhook signature verification](/platform/webhook): validate HMAC-SHA512 on all incoming webhooks
* [Currency conversion](/platform/convert): when the held currency differs from the withdrawal currency, use the Convert feature with a Main → Trade → Convert → Trade → Main transfer pattern — see [Payment Integration](/guides/payment-integration) for the full flow

**Reconciliation:**

* Primary: webhook-based notifications for deposits and withdrawals
* Fallback: poll the deposit/withdraw history endpoint for reconciliation
* Deduplication: use `uniqueId` across both channels
* See the [Payment Integration](/guides/payment-integration) guide for the full reconciliation strategy

## Prop trading firms

Prop trading firms need deep liquidity, low-latency execution, and sub-accounts that isolate balances and API keys for each trader or strategy.

**Recommended products:**

* [Sub-Accounts](/products/sub-accounts/overview) — isolate strategies with independent balances and API keys; assign role-based access for traders, risk managers, and operations
* [Colocation](/platform/colocation) — minimize execution latency with co-located infrastructure
* [Market-Making Program](https://institutional.whitebit.com/market-making-program) — maker rebates for firms running spread-capture or liquidity strategies

**Infrastructure considerations:**

* Use per-sub-account API keys with IP whitelists for security isolation between trading desks
* Block or unblock sub-accounts via API to enforce automated risk controls
* Monitor balances across all sub-accounts via `POST /api/v4/sub-account/balances`

**Get started:** [institutional.whitebit.com/prop-trading-companies](https://institutional.whitebit.com/prop-trading-companies) or contact [institutional@whitebit.com](mailto:institutional@whitebit.com).

## Institutional clients

Institutional clients — hedge funds, asset managers, family offices, banks, fintechs, and exchanges — access the institutional product catalog through institutional onboarding. The onboarding process covers KYB verification, fiat access approval, and dedicated account management.

The institutional product catalog includes OTC Trading, Portfolio Margin (200,000 USDT minimum), Crypto-as-a-Service (CaaS), Wallet-as-a-Service (WaaS), and Custody solutions. See the [Institutional Overview](/institutional/overview) for the full product matrix and the [Institutional Onboarding](/institutional/onboarding) guide for the step-by-step process.

Contact [institutional@whitebit.com](mailto:institutional@whitebit.com) to begin the onboarding process.

## REST vs. WebSocket decision matrix

| Use case                       | Recommended                                     | Reason                                      |
| ------------------------------ | ----------------------------------------------- | ------------------------------------------- |
| Live prices                    | WebSocket (`lastprice` channel)                 | No polling needed; instant updates          |
| Orderbook depth                | WebSocket (`depth` channel)                     | Real-time depth snapshots                   |
| Place / modify / cancel orders | REST API                                        | Request-response pattern with confirmation  |
| Monitor balances               | WebSocket (`balanceSpot` / `balanceCollateral`) | Real-time balance changes                   |
| Fetch historical trades        | REST API                                        | One-time queries, paginated                 |
| Check open orders              | REST or WebSocket                               | REST for on-demand; WebSocket for real-time |

Combining REST for order management with WebSocket for market data is the most common integration pattern.

## What's Next

<CardGroup cols={2}>
  <Card title="First API Call" icon="rocket" href="/guides/first-api-call">
    Make a first authenticated API call in 5 minutes.
  </Card>

  <Card title="SDKs" icon="code" href="/sdks">
    Official SDKs in Go, Python, and PHP.
  </Card>
</CardGroup>
