top of page

IBKR FA Allocation (2026): One Order, Many Client Accounts

4 minutes ago
14 min read
IBKR FA allocation: one order across many client accounts cover

AI Summary: IBKR FA allocation lets an Interactive Brokers Financial Advisor account send one block order to an allocation group and have IBKR split the fills across client sub-accounts at the same average price. Automating it safely also needs a deliberate rounding rule, a buying-power pre-check, a check of IBKR’s actual split, separate groups for different investor tiers, duplicate-order protection and reconciliation by permId. This guide covers the TWS API and the Web API.


FaGroup and FaMethod, the TWS API vs the Web API, equal vs NetLiq, rounding, two investor groups and reconciliation, from a live system


If you manage money for a group of people on Interactive Brokers, every trade has to happen across multiple accounts, sometimes 15 times over. Hand-allocating in TWS works until the market moves faster than your clicks. One account fills, another misses, a third gets the wrong size, and by the time you’ve finished the spread has moved. IBKR FA allocation solves the execution side. With an Interactive Brokers Financial Advisor account, you send one order and IBKR splits it across your client accounts, so you can copy trades across multiple accounts at the same price. Automating it safely takes more than setting two fields on an order.


We built a production system that does this for a multi-account options desk. One signal fires, one order goes to IBKR, and every client account gets its share, an exit order, and a reconciled record. This guide walks through the full loop, including the parts the API documentation leaves out: rounding, buying power, checking IBKR’s split, running two investor groups off one signal, and catching fills your software never heard about.


Key takeaways


  1. Through the TWS API, every FA order names its allocation group in faGroup. Set faMethod explicitly too, and test the method strings on a paper advisor account.

  2. Use one FA-group order, not 15 separate orders, so every account gets the same fill price.

  3. Options contracts can’t be split, so decide your rounding rule on purpose.

  4. Check each account’s available funds before submitting, and log every excluded account.

  5. IBKR’s split is the official one. Compute your own expected split only to catch surprises.

  6. Give each investor group its own FA group, size and exit.

  7. Reconcile against IBKR’s executions by permId. In our system, fills from earlier sessions arrived with orderId = 0.


Why copying trades by hand across multiple IBKR accounts breaks


Manual allocation fails in predictable ways, and each one costs clients money or creates a compliance headache:


  • Price drift. The tenth account fills at a worse price than the first. Clients in the same strategy get different results for no reason they can see.

  • Missed accounts. Someone gets skipped under time pressure and nobody notices until the monthly statement.

  • Wrong sizes. Each account’s quantity is worked out in a spreadsheet and typed by hand.

  • Unprotected positions. Exits have to be placed per account too. If the trader steps away, some accounts have a profit target and some don’t.


Copy-trading tools patch parts of this. The cleaner fix is to use the allocation engine IBKR already runs for advisors, and build the controls around it.


Copy trading across multiple IBKR accounts: FA allocation vs separate orders


There are two ways to copy one trade into many Interactive Brokers accounts. You can send one order per account, or send one block order to an FA allocation group and let IBKR split it. For an advisor, the block order wins on almost every count:



One FA block order

Separate order per account

Fill price

Same average price for every account

Each account fills at its own price

Orders to manage

One per group

One per account (15 entries, 15 exits)

Fairness evidence

IBKR’s allocation record

You must prove it yourself

Account structure needed

IBKR Financial Advisor (master + sub-accounts)

Any accounts you can trade via API

When it fits

Advisors and managed groups

Unrelated accounts that can’t sit under one advisor


The rest of this guide assumes the FA route.


How IBKR FA allocation works (FaGroup + FaMethod)


An IBKR Financial Advisor (FA) account is a master account with linked client sub-accounts. In TWS or IBKR’s web portal you create an allocation group: a named list of sub-accounts plus a method for splitting orders between them. When you submit an order against that group, IBKR executes it as one block and splits the fills across the accounts.


Through the TWS API, IBKR’s FA order placement docs show the essential step: put the allocation group’s name in the order’s faGroup field. The Order object also has faMethod (the allocation method) and faPercentage fields. We set faMethod explicitly on every order, so the method is visible in every order record rather than implied by a group setting someone can change. IBKR also recommends setting your allocation preference under Global Configuration, Advisor Setup, Presets in TWS to avoid wrong allocation results.


from ib_async import IB, Contract, Order

def fa_group_order(con_id, qty, limit_price, group="GROUP_A", method="Equal"):
    contract = Contract(conId=con_id, exchange="SMART")
    order = Order(
        action="BUY",
        orderType="LMT",
        totalQuantity=qty,          # total across ALL accounts in the group
        lmtPrice=float(limit_price),
        tif="DAY",
        faGroup=group,              # the allocation group name
        faMethod=method,            # how IBKR splits the fills; test the string on paper
    )
    return contract, order

# trade = ib.placeOrder(*fa_group_order(con_id, 15, 4.20))

IBKR’s current groups and allocation methods documentation describes two kinds of method. IB-computed methods (Available Equity, Equal Quantity and Net Liquidation Value) are calculated by IBKR from each account’s values. User-specified methods (percentages, ratios, shares and monetary or cash amounts, formerly known as allocation profiles) apply numbers you define. Both now sit inside allocation groups. You can create groups in TWS, or manage them from code with requestFA / replaceFA. Note that IBKR says changes made through the API also affect orders placed through TWS, Client Portal and the Web API.


Three practical notes:


  • The group must already exist at IBKR. If the name doesn’t match a configured group, the order won’t be allocated the way you intended. Create the groups in TWS (or with the API’s replaceFA) before going live, and keep the names in config, not in code.

  • Check the exact method strings against your Gateway version. IBKR’s current group definitions use Equal, NetLiq and AvailableEquity, while older documentation and some wrappers use EqualQuantity and PctChange. Test every method you plan to use against a paper advisor account.

  • Use one block order, not one order per account. A single FA order means every client gets the same average price, and you have one order to manage instead of 15.


FA allocation with the TWS API vs the IBKR Web API


IBKR has two developer APIs, and FA allocation works differently in each. The TWS API talks to a running TWS or IB Gateway over a socket. The Web API (also called the Client Portal API) is a REST interface.



TWS API (via IB Gateway)

IBKR Web API (Client Portal API)

How you target the group

faGroup on the order (with faMethod or faPercentage where needed)

Put the allocation group’s name where the account ID goes in the order request

Managing groups

requestFA / replaceFA

/iserver/account/allocation/group endpoints (list, add, modify, delete)

One-off allocations

Set the method per order

In-line allocation orders through the order’s jsonPayload field, added on February 10, 2026

Per-account fills

Execution details per sub-account

The group order isn’t listed with the sub-account orders. Query each account’s orders separately.

Runs on

IB Gateway or TWS (Java app, headless with IBC)

REST calls behind an authenticated session

Best for

Low-latency, event-driven systems

Lighter integrations and REST-first stacks


# Web API sketch: the allocation group name replaces the account ID.
# Check field names against IBKR's current Web API reference.
POST /v1/api/iserver/account/GROUP_A/orders
{
  "orders": [{
    "conid": 123456789,
    "orderType": "LMT",
    "price": 4.20,
    "side": "BUY",
    "quantity": 15,
    "tif": "DAY"
  }]
}

We built on the TWS API through a headless IB Gateway, because we wanted fills streamed per account in real time. Whichever API you choose, every other section of this guide still applies: rounding, buying power, checking the split, groups, duplicate protection and reconciliation. For a broader comparison of IBKR’s APIs, see how to integrate the Interactive Brokers API with a fintech or trading platform.


Equal vs NetLiq vs AvailableEquity: choosing a method


Method

How IBKR splits the order

Use it when

Equal Quantity (Equal)

Same number of shares or contracts to every account. Any remainder is handed out one unit at a time until all are distributed.

Accounts are similar in size, or clients have agreed to equal positions. Simplest to explain.

Net Liquidation Value (NetLiq)

In proportion to each account’s net liquidation value

Account sizes vary a lot and you want risk to scale with each account’s equity.

Available Equity (AvailableEquity)

In proportion to each account’s available equity

You want sizing to reflect what each account can actually afford right now.

Percentages

Changes each account’s existing position by the percentage you set (no order size)

Rebalancing existing positions. Rarely used for new options entries.

Ratios, shares or monetary amount (formerly allocation profiles)

Fixed ratio or amount per account that you define

Clients have agreed, documented sizing ratios that don’t follow account value.


We used Equal Quantity for each group, because the client’s groups were already arranged by account size (more on that below). That gives every account in a group an identical position, which is the easiest thing for clients to understand.


The rounding problem: 16 contracts, 15 accounts


Options contracts can’t be split. With 16 contracts and 15 accounts, one account gets 2 and the rest get 1. With NetLiq weighting, nearly every account’s fair share is a fraction. How the leftovers are handed out is a fairness decision, so make it on purpose.


Even though IBKR does the official split, you need your own model of it, both to show clients what to expect and to check IBKR’s result. We use the largest-remainder method: give every account the whole-number part of its share, then hand the leftover contracts to the accounts with the largest fractions. Unlike rounding each account separately, this always adds up exactly to the order size.


from decimal import Decimal

def equal_split(total: int, accounts: list[str]) -> dict[str, int]:
    base, remainder = divmod(total, len(accounts))
    return {a: base + (1 if i < remainder else 0) for i, a in enumerate(accounts)}

def weighted_split(total: int, weights: dict[str, Decimal]) -> dict[str, int]:
    w_sum = sum(weights.values())
    raw = {a: total * w / w_sum for a, w in weights.items()}
    result = {a: int(v) for a, v in raw.items()}
    leftover = total - sum(result.values())
    for a in sorted(raw, key=lambda a: raw[a] - result[a], reverse=True)[:leftover]:
        result[a] += 1
    return result

Account

NetLiq

Exact share of 9

Whole part

Final

DU000001

$400,000

3.6

3

3

DU000002

$300,000

2.7

2

3 (+1)

DU000003

$200,000

1.8

1

2 (+1)

DU000004

$100,000

0.9

0

1 (+1)

Total

$1,000,000

9.0

6

9


The whole parts add up to 6, so the three leftover contracts go to the accounts with the largest fractions (0.9, 0.8 and 0.7). Rounding each account on its own would give 4 + 3 + 2 + 1 = 10 contracts for a 9-contract order, one more than you are buying. Account numbers and values here are illustrative.


Fairness tip. In an equal split, a fixed tie-break order (“leftovers go to the first accounts in the list”) gives the same clients the extra contract on every trade. That is a bias you may have to explain to clients or an auditor. Rotate who gets the leftover, or make the order size a multiple of the account count, and write the rule down in your allocation policy.


Check buying power before you send the order


One underfunded account can get the whole block order rejected or partly allocated. Before submitting, pull each sub-account’s available funds and drop the accounts that can’t afford their share, with a safety buffer:


def preflight(buying_power: dict[str, Decimal], est_price: Decimal,
              contracts_each: int, buffer=Decimal("1.05")):
    need = est_price * contracts_each * 100 * buffer   # options multiplier = 100
    funded, excluded = [], {}
    for acct, bp in buying_power.items():
        if bp >= need:
            funded.append(acct)
        else:
            excluded[acct] = f"insufficient funds: {bp:.2f} < {need:.2f}"
    return funded, excluded

Two rules matter more than the code. Never skip an account silently. Every exclusion is logged with its reason and shown in the trade notification, so the advisor knows exactly who sat the trade out. And use the AvailableFunds tag from the account summary rather than headline BuyingPower for long option purchases. Long options are generally paid for in full, so margin buying power overstates what an account can really buy.


Trust IBKR’s split, but verify it


IBKR’s allocation is the official record. Your own calculation is only a check. After the order fills, read the per-account fills IBKR reports and compare them with your expected split:


def check_variance(expected: dict[str, int], actual: dict[str, int], tolerance: int):
    accounts = set(expected) | set(actual)      # a missing account counts in full
    worst = max(abs(expected.get(a, 0) - actual.get(a, 0)) for a in accounts)
    return worst, worst > tolerance

If the gap goes over a configured tolerance (we default to a contract or so), the system records it and sends an alert. This catches problems you’d otherwise only find on statements: a sub-account removed from the group in the portal, a group edited by hand, a partial fill shared out differently than you expected, or a rounding rule that doesn’t match yours. Store both the expected and the actual split for every trade. It is the cheapest audit evidence you will ever produce.


Two investor groups, one signal


Real advisor books are rarely uniform. Our client had two kinds of investor: larger accounts that wanted bigger positions and a higher profit target, and smaller accounts that wanted smaller positions and a quicker exit. Both followed the same signal.


The clean design is two FA groups, each with its own size and its own profit target, both driven by one signal.


Setting

Group A (illustrative)

Group B (illustrative)

IBKR FA group

GROUP_A

GROUP_B

Accounts

6 larger accounts

9 smaller accounts

Contracts per order

12

9

Profit target per contract

$400

$250

Exit order

Own GTC limit, per group

Own GTC limit, per group


When the signal fires, the system sends two FA orders, one per group, at the same entry price. When each one fills, it works out that group’s exit price from that group’s own average fill and profit target, and places a resting GTC exit against the same group:


def exit_price(avg_fill: Decimal, target_per_contract: Decimal,
               commission_buffer: Decimal = Decimal("0")) -> Decimal:
    # option prices are quoted per share; one contract = 100 shares
    return avg_fill + (target_per_contract + commission_buffer) / 100

target = cfg.group_targets[order.fa_group]      # resolved from the entry's group
place_gtc_exit(fa_group=order.fa_group, qty=filled_qty,
               price=round_to_tick(exit_price(order.avg_fill, target)))

Three details made this hold up in production:


  • Tag every order with its group. The exit, the reconciliation and the P&L all look up targets by the group recorded on the entry order, never by “whatever the current config says.”

  • Keep sizes, targets and account lists in config, not code, so the advisor can rebalance groups without a release. Store every config change in a history table.

  • Round to the exchange tick. A computed exit price like 6.7325 is rejected. Snap it to a valid price increment before submitting.


Never double-allocate: one ID per signal and account


Retries are where multi-account systems lose money. If a submit times out and the code tries again, IBKR may already have accepted the first order. Give every order a key built from the signal ID and the account or group, store it with a unique constraint before calling IBKR, and refuse to submit a second order with the same key:


idempotency_key = f"{signal_id}__{fa_group_or_account}"
# INSERT order row with UNIQUE(idempotency_key) BEFORE calling IBKR.
# A retry hits the constraint and becomes a status check, not a second order.

Writing the record before the broker call also means a crash halfway through leaves a row saying “we might have sent this,” which reconciliation then resolves against IBKR’s records.


Reconciling against IBKR’s own records


Your database is a copy. IBKR is the source of truth. Fills happen while your app is restarting, while the Gateway is in its nightly restart, or after someone trades by hand in TWS. A reconciliation loop pulls IBKR’s open orders and executions on a schedule and after every reconnect, and compares them with your records:


  • Order on IBKR, not in your DB: someone traded by hand, or a submit succeeded that your app thought had failed. Alert and record it, never cancel automatically.

  • Order in your DB, gone from IBKR, no matching execution: cancelled or rejected outside your app. Mark it and alert.

  • Execution on IBKR your DB never saw: a missed fill. Record it, close the position and work out P&L from IBKR’s price.

  • Exit order missing while the position is still open: an unprotected position. Replace the exit, but only after checking IBKR’s positions, so you never sell twice.


Two limits shape the schedule. IBKR’s execution details docs say execution requests return executions since midnight by default, and IB Gateway is limited to the current trading day. So reconcile at least daily, and use statements or reports for anything older.


Reconciliation only works if the Gateway connection itself is reliable. See keeping IB Gateway connected: our headless IB Gateway guide for the reconnect loop and alerts that feed this step.


The orderId = 0 trap with cross-session GTC fills


This one cost us a manual clean-up before we fixed it. Exit orders rest at IBKR as GTC orders, often across several days. In our system, when a GTC order placed in an earlier session filled, the execution reported through the API carried orderId = 0. IBKR documents orderId as the API client’s order ID, which may not be unique to an account, while permId is IBKR’s own order identifier. Our fill handler matched on order ID, found nothing, and ignored the fill. The position stayed “open” in our database even though it had closed at IBKR.


The fix is to match on the identifier that survives across sessions, permId, and fall back in tiers:


Tier

Match on

When it applies

1

permId (IBKR’s permanent order ID, saved when you submit)

Always try first. Survives restarts and session resets.

2

API orderId

Same-session fills where orderId is not 0

3

Account + full OCC option symbol + sell-to-close + still-working status

Last resort, for when no permId was saved

—

No match

Don’t place a replacement exit. Alert a human.


Store the permId the moment IBKR acknowledges an order. It costs one column and turns a manual-review incident into an automatic close.


Production checklist


  • FA groups created at IBKR; group names, sizes, targets and account lists in config with change history

  • faGroup and faMethod on every API order; method strings tested on a paper advisor account

  • One block order per group, never one order per account

  • Written rounding and leftover policy; rotation if you use a fixed tie-break

  • Buying-power pre-check using AvailableFunds, with every exclusion logged and reported

  • Expected vs actual split saved for every trade; alert when over tolerance

  • Exit price from each group’s own average fill and target, snapped to tick size, placed as GTC right after the fill

  • Order key built from signal + group/account, written before the broker call

  • permId saved on every order; tiered fill matching

  • Reconciliation on a schedule and after every reconnect; no automatic cancels on mismatch

  • Every decision written to an append-only audit log


FAQ


What is IBKR FA allocation?

FA allocation is how an Interactive Brokers Financial Advisor account splits one order across linked client accounts. You define an allocation group and a method, such as equal quantity or net liquidation value, and IBKR executes one block order and shares the fills out between the accounts.

Do I have to set FaGroup and FaMethod on every API order?

Set faGroup on every FA order: that is how IBKR knows which allocation group to split it across. We also set faMethod explicitly on every order and test the method strings on a paper advisor account, so the allocation method is never left to a preset or a group setting someone changed.

Should I use EqualQuantity or NetLiq?

Use Equal Quantity when accounts are similar in size or clients have agreed to identical positions. Use NetLiq when account sizes vary and risk should scale with equity. Many advisors run separate groups, each using Equal Quantity, so each group stays uniform and easy to explain.

How are leftover option contracts allocated?

Contracts can’t be split, so some accounts get one more than others. Decide the rule on purpose. Largest-remainder keeps totals exact for weighted splits. For equal splits, rotate who gets the leftover so the same clients aren’t always favoured, and document the policy.

How do I copy trades across multiple IBKR accounts?

Use an Interactive Brokers Financial Advisor structure and send one order against an allocation group. Every account gets the same average price and you manage one order instead of many. Placing separate orders per account also works, but fills drift and you must manage each order.

What is the difference between an allocation group and an allocation profile?

An allocation group is a named list of accounts plus a method that IBKR uses to split each order. IBKR has folded what it used to call allocation profiles into groups: its documentation now lists them as user-specified methods, such as fixed percentages, ratios or share amounts per account.

Can I place FA allocation orders through the IBKR Web API?

Yes. In the Web API you put the allocation group’s name where the account ID normally goes in the order request, and manage groups through the allocation group endpoints. Since February 2026 you can also send in-line allocations in the order’s jsonPayload field. The group order isn’t listed with each sub-account’s orders, so query them separately.

Why does IBKR report orderId 0 on some fills?

In our system, fills on GTC orders placed in an earlier API session arrived with orderId 0. IBKR documents orderId as the API client’s order ID, which may not be unique, and permId as IBKR’s own order identifier. Match executions by permId and save it on every order you submit.


Conclusion


Setting two fields on an order is the easy part of IBKR FA allocation. The hard part is everything around it: deciding how contracts are shared out, checking who can afford the trade, verifying IBKR’s split, giving each investor group its own size and exit, never sending an order twice, and reconciling against IBKR’s records when your software missed something. Get those right and one signal reliably becomes 15 fairly treated, protected positions.


If you are building for RIAs and advisors more broadly, see our wealth and investment app development services for US financial advisors, and for signal-driven automation on IBKR, our write-up on TradingView alert automation with Interactive Brokers.


We build trading automation for advisors and copy-trading groups on Interactive Brokers. If you are allocating by hand today, book a call with our team.


imgi_48_Arpan Desai Profile Photo (1).png

About Author 

Arpan Desai

CEO & FinTech Expert

Arpan brings 14+ years of experience in technology consulting and fintech product strategy.
An ex-PwC technology consultant, he works closely with founders, product leaders, and API partners to shape scalable fintech solutions.

 

He is connected with 300+ fintech companies and API providers and is frequently involved in early-stage architectural decision-making.

Rectangle 6067.png

Contact Us

Are you looking to build a robust, scalable & secure Fintech solution?
bottom of page