> This page is for Trading.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.immix.xyz/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.immix.xyz/_mcp/server.

# List approvals

GET /approvals

Lists the organisation's proposals — `pending` (the default), `returned` with the reason, or `concluded`, the audit — across accounts (keys too), addresses, policies, approval rules and notification endpoints, each with the approved record beside it and who may approve. Only the families your capabilities read are listed; `mine=true` is the items awaiting you. Ordered by `family`, then `entityId`.

Reference: https://docs.immix.xyz/trading/api-reference/rest-api/approvals/list

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Query parameters

- `status` (enum, optional) — `pending` (the default): the rows with a proposal awaiting approval. `returned`: the rows whose last proposal was withdrawn — by its maker or by a checker, with the reason — and nothing proposed since; the item carries who returned it, when and why. `concluded`: the rows whose last proposal concluded — the audit list: who proposed it, who approved when, who concluded it and when (the maker, where the count was 0 and the write concluded at once). Any other value refuses 400.
  - Allowed values: `pending`, `returned`, `concluded`
- `mine` (boolean, optional) — `true`: only the pending items awaiting your approval — you are a person holding the family's `approve` capability, you are not the maker — nor, when an API key made it, the key's issuer or the `keyHolder` its `after` row names — and you have not approved yet (the `approvers` list names you; it never names a service client). Its `total` with `include=total` is the count for a bell. Absent or `false`: every item you read; with `status=returned` or `status=concluded` it refuses 400, since neither a returned nor a concluded item awaits anybody.
- `proposedBy` (enum, optional) — `me`: only the proposals you made — pending ones by default, with `status=returned` the ones returned to you, each with its reason, or with `status=concluded` the ones that concluded. The one value it takes; any other refuses 400.
  - Allowed values: `me`
- `family` (enum, optional) — Only rows whose `family` is one of these; repeat the parameter or comma-separate, at most 100 values. A value the row cannot carry (not one of the values listed) refuses 400 `MALFORMED_REQUEST`; a value naming no row yields an empty collection. A family by its resource segment; `account-addresses` is a declared or observed address awaiting verification, `approval-rules` a lowering pending on one of your organisation's approval rules, `notifications` a new or amended notification endpoint.
  - Allowed values: `accounts`, `account-addresses`, `asset-policies`, `chain-policies`, `trading-policies`, `approval-rules`, `risk`, `transfers`, `notifications`
- `entityId` (integer, optional) — Only rows whose `entityId` is one of these; repeat the parameter or comma-separate, at most 100 values. A value the row cannot carry (not a positive 32-bit integer) refuses 400 `MALFORMED_REQUEST`; a value naming no row yields an empty collection.
- `transferId` (string, optional) — Only rows whose `transferId` is one of these; repeat the parameter or comma-separate, at most 100 values. A value the row cannot carry (not a positive 64-bit integer in decimal digits) refuses 400 `MALFORMED_REQUEST`; a value naming no row yields an empty collection.
- `transition` (enum, optional) — Only rows whose `transition` is one of these; repeat the parameter or comma-separate, at most 100 values. A value the row cannot carry (not one of the values listed) refuses 400 `MALFORMED_REQUEST`; a value naming no row yields an empty collection.
  - Allowed values: `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `returnedBy` (enum, optional) — Only rows whose `returnedBy` is one of these; repeat the parameter or comma-separate, at most 100 values. A value the row cannot carry (not one of the values listed) refuses 400 `MALFORMED_REQUEST`; a value naming no row yields an empty collection.
  - Allowed values: `maker`, `checker`
- `sort` (string, optional, default: family,entityId,transferId) — Comma-separated `family`, `entityId`, `transferId`, `transition`, `proposedAtNs`, `requiredApprovals`, `concludedAtNs`, `returnedAtNs` or `returnedBy`; prefix `-` for descending. Default `family,entityId,transferId`.
- `limit` (integer, optional) — Page size, 1-100; larger values are clamped. Without it the whole collection is served as one page.
- `cursor` (string, optional) — `nextCursor` or `prevCursor` from a previous page, sent with the same filters and the same `sort`. One that does not decode, or that came from another query, is refused 400 `INVALID_CURSOR`: drop it and fetch the first page.
- `include` (enum, optional) — `total` adds the exact number of rows matching the filters. This collection has no terminal state, so `include` takes `total` alone: `deleted` is a value off its grammar (400).
  - Allowed values: `total`
- `minGlobalSequence` (string, optional) — A position you hold — an `X-Immix-Global-Sequence` you read, or a 202's `commandGlobalSequence`: this member answers only once it has folded the platform's stream through it, waiting up to its deadline, then 503 `PROJECTION_BEHIND` with `Retry-After`. Within that stream a read is never older than what you have seen; drop your positions after an announced stream cut. A retry stating its 202's position attaches to or replays that operation while the journal holds its key, never publishing twice. Stated once: one to nineteen digits, at most 9223372036854775807; else 400 `MALFORMED_REQUEST`.

### Headers

- `X-Request-Id` (string, optional) — Your own id for the request: 8 to 128 of `[A-Za-z0-9._-]`. It becomes the request's id and is echoed on the response. A value off that grammar is replaced with a fresh id, never refused.

## Response

### 200

A page of the proposals the caller reads, by family then `entityId` or in the order `sort` asks — all of them unless `limit` is sent; the position it was read at rides the body and the headers.

- `asOfSeqTsNs` (string, required, nullable) — The sequencer timestamp (epoch-ns) the data is complete through; also sent as X-Immix-As-Of-Seq-Ts. Null when unknown.
- `globalSequence` (string, required) — The position as a decimal string — the last change this member had applied, orders, balance readings and algo instances included.
- `items` (list of ApprovalItem, required)
- `nextCursor` (string, required, nullable) — Pass as `cursor` for the next page. Null on the last page.
- `prevCursor` (string, required, nullable) — Pass as `cursor` for the previous page. Null on the first page.
- `total` (integer, required, nullable) — Exact count matching the filter. Null unless `include=total`.

## Errors

### 400 List Approvals Request Bad Request Error

The request's shape is wrong: a non-positive id, an unknown `view` or filter value, a query string that does not decode, a query parameter the operation does not take, or a cursor that does not decode or came from another query (`INVALID_CURSOR`). No position rides a refusal that consulted no state.

- `error` (ErrorBody, required) — What a refusal states. Since `0.12.0` every refusal carries all four members; a member below it sends `code`, sometimes `message`, and neither of the others.
- `currentVersion` (string, optional) — On 412 `VERSION_CONFLICT`, or `CONFIG_SEQ_CONFLICT` on an algo instance's config write: the row's current version (the `ETag` carries the same token) — re-read, reapply, retry.

### 401 List Approvals Request Unauthorized Error

No bearer token, or one that does not verify.

- `error` (ErrorBody, required) — What a refusal states. Since `0.12.0` every refusal carries all four members; a member below it sends `code`, sometimes `message`, and neither of the others.
- `currentVersion` (string, optional) — On 412 `VERSION_CONFLICT`, or `CONFIG_SEQ_CONFLICT` on an algo instance's config write: the row's current version (the `ETag` carries the same token) — re-read, reapply, retry.

### 403 List Approvals Request Forbidden Error

`CAPABILITY_DENIED`: a read your capabilities do not cover, or a staging route without its propose bit (`accounts:propose`). `NOT_REGISTERED`: no row or open invitation at your verified address, an unknown organisation, or an unclaimed row (an administrator admits it). `EMAIL_UNVERIFIED`: verify, then sign in again. `INVITATION_EXPIRED`: an administrator re-invites. `FORBIDDEN_PRINCIPAL`: no `org_id`, a non-ASCII ref, a disabled user, a binding with no user. `ORG_NOT_ACTIVE`: disabled, pending or deleted. Owners' 403s carry the position header and `Idempotent-Replay`.

- `error` (ErrorBody, required) — What a refusal states. Since `0.12.0` every refusal carries all four members; a member below it sends `code`, sometimes `message`, and neither of the others.
- `currentVersion` (string, optional) — On 412 `VERSION_CONFLICT`, or `CONFIG_SEQ_CONFLICT` on an algo instance's config write: the row's current version (the `ETag` carries the same token) — re-read, reapply, retry.

### 503 List Approvals Request Service Unavailable Error

This member is still catching up (`NOT_PRIMED`; retry shortly), or had not folded through the `minGlobalSequence` you sent by the deadline (`PROJECTION_BEHIND`; retry after `Retry-After`).

- `error` (ErrorBody, required) — What a refusal states. Since `0.12.0` every refusal carries all four members; a member below it sends `code`, sometimes `message`, and neither of the others.
- `currentVersion` (string, optional) — On 412 `VERSION_CONFLICT`, or `CONFIG_SEQ_CONFLICT` on an algo instance's config write: the row's current version (the `ETag` carries the same token) — re-read, reapply, retry.

## Types

### ApprovalItem

One proposal as the inbox serves it: the row's family and id, what is proposed and whether it is awaiting approval, was returned or concluded, the maker, when it was made and the approvals the policy in force requires, who has approved and when and who still may, on a concluded item who concluded it and when, the enforced record beside the proposed one — each in the family's own row shape — the maker's note, and on a returned item who returned it, when and why.

- `family` (enum, required) — The row's family — its resource segment, naming the row shape `before` and `after` carry (`accounts` carries the account row with its `keys[]` — a change to one of its keys is the account's own proposal, `transition` `KEY_CHANGE`, the key's proposed image in `after.keys[]` and the enforced one in `before.keys[]` — `approval-rules` the rule, `risk` the limit row, `transfers` the transfer, `notifications` the endpoint, and so on). Reading a family needs its read capability, so a family you cannot read never appears; the organisation lifecycle's proposals are the internal platform API's inbox's.
  - Allowed values: `accounts`, `account-addresses`, `asset-policies`, `chain-policies`, `trading-policies`, `approval-rules`, `risk`, `transfers`, `notifications`
- `entityId` (integer, required, nullable) — The row's id in its family — `GET /{family}/{entityId}` is the row, and `POST /{family}/{entityId}/approve` or `/withdraw` under its `ETag` concludes or returns it. Four families differ: `account-addresses` approves at `/account-addresses/{entityId}/verify` and has no withdraw (its proposal ends at `/delete`); `risk` reads `GET /risk/limits/{entityId}` and decides under `/risk/limits/{entityId}/proposal/approve` or `/withdraw`; `transfers` names its row in `transferId`, and this is `null`; `notifications` is at `/notifications/endpoints/{entityId}`, with `/approve` and `/withdraw` under it.
- `transferId` (string, required, nullable) — On a `transfers` item, the transfer — a 64-bit id, so decimal digits in a member of its own: `GET /transfers/{transferId}` is the row, and `POST /transfers/{transferId}/approve` or `/withdraw` under its `ETag` concludes or returns it. Such an item's `transition` reads `ACTIVATE` for a submitted transfer and `AMEND` for a resolution by hand. `null` on every other family's item.
- `transition` (enum, required, nullable) — What the proposal proposes, one word per act: `ENABLE` for an account's enable, `DELETE` for any family's delete (a risk limit's retirement included), `KEY_CHANGE` for a change to one of an account's keys — added, amended, rotated, enabled or deleted; the key's own `pendingTransition` in `after.keys[]` says which (0.65.0). On a concluded item, what the conclusion cleared (the row's `concludedTransition`), however its `status` has moved on since; `null` on a returned item. The value set is append-only: treat an unknown name as unknown, never as an error.
  - Allowed values: `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `status` (enum, required) — `pending`: awaiting approval. `returned`: withdrawn by its maker or a checker, nothing proposed since — the item stands until the row's next proposal. `concluded`: the row's last proposal concluded — the audit list, each item carrying what concluded (`transition`), who concluded it and when.
  - Allowed values: `pending`, `returned`, `concluded`
- `proposedBy` (Actor, required, nullable) — The maker — a member or an API key — kept on the record once it concluded; `null` when a connector made it (an observed address).
- `proposedAtNs` (string, required, nullable) — When the proposal was made, platform time in epoch nanoseconds as a decimal string; `null` on a returned item for a lowering of an approval rule that a colleague's raise superseded — the row's record is the raise's from then on, so the lowering's clock is no longer held — and on a proposal made by a member below 0.25.0, which stamped none.
- `requiredApprovals` (integer, required) — The approvals a proposal of the family is judged by: your organisation's count for the family as the policy stands now, so raising a count reaches a proposal already pending. On an organisation's lifecycle proposal and on an approval rule's lowering, 1. On a returned or concluded item, the same count in force now — a concluded item's `approvals` says how many it took.
- `approvals` (list of ApprovalItemApprovalsItem, required) — Who has approved so far and when, in approval order; empty until the first approval, and empty on a returned item. On a concluded item, every approval it took.
- `approvers` (list of ApprovalItemApproversItem, required) — Who may still approve: the organisation's active people holding the family's `approve` capability (for an approval rule's lowering, `org:manage`) — never an API key, which holds no approve capability — other than the maker (when an API key made it, the key's issuer and the `keyHolder` its `after` row names too) and those in `approvals`, ascending by `userId`. Empty on a pending item means no one else can approve yet — invite or grant before it can conclude; empty on a returned item, which awaits nobody.
- `concludedAtNs` (string, required, nullable) — When the proposal concluded, platform time in epoch nanoseconds as a decimal string — on a `concluded` item; `null` while pending and on a returned item. Equal to `proposedAtNs` on a write the count let through at once.
- `concludedBy` (Actor, required, nullable) — Who concluded it — the approver whose approval met the count, or the maker (a member or an API key) where the count was 0 and the write concluded at once; `null` while pending and on a returned item.
- `before` (ApprovalImage, required, nullable) — The approved record beside the proposal — the row as `view=approved` serves it, in the family's own shape: what the row returns to if the proposal is withdrawn. `null` on an `ACTIVATE` (a new credential, policy or organisation, a discovered account, a re-proposed draft — nothing stands to compare with, however many approvals the proposal has gathered) on every returned or concluded item, and on every `transfers` item — a transfer is one record, its pending proposal's content beside its own state, all of it in `after`. Compare with `after` for what the proposal changes.
- `after` (ApprovalImage, required) — The proposed record — the row as `view=latest` serves it, in the family's own shape; on a returned item, the row as it stands after the withdrawal (the enforced record restated where one was enforced; otherwise the not-yet-live record as it stands); on a concluded item, the row as it stands now — the conclusion's content as any later single-user act (a disable, a halt, an address's delete) or machine fact left it; the item's own members say what concluded and who, `after.status` what the row is now.
- `remark` (string, required) — The maker's note on the proposal; empty when none was given, and empty on a returned item for a lowering a raise superseded (the row keeps the raise's note, not the lowering's).
- `returnedByActor` (Actor, required, nullable) — Who returned it — the maker, or a checker; `null` while pending. An item the platform's disabling of the organisation released names no member of the platform: an organisation never learns which platform member acted.
- `returnedAtNs` (string, required, nullable) — When it was returned, platform time in epoch nanoseconds as a decimal string; `null` while pending.
- `reason` (string, required) — Why it was returned, as the withdrawer stated it; empty while pending or when none was given.
- `returnedBy` (enum, required, nullable) — `maker` when the proposer withdrew their own proposal, `checker` when someone else returned it (a colleague, or the platform disabling the organisation — then `returnedByActor` names no platform member); `null` while pending.
  - Allowed values: `maker`, `checker`

### ErrorBody

What a refusal states. Since `0.12.0` every refusal carries all four members; a member below it sends `code`, sometimes `message`, and neither of the others.

- `code` (string, required) — The code to branch on — stable and open (before 1.0.0 a minor may remove one, its changelog naming it): treat one you do not know by its HTTP status. The gateway's: - 400: `MALFORMED_REQUEST`, `MISSING_IDEMPOTENCY_KEY`, `INVALID_IDEMPOTENCY_KEY`, `INVALID_IF_MATCH`, `INVALID_CURSOR` - 401: `UNAUTHENTICATED` - 403: `FORBIDDEN_PRINCIPAL`, `NOT_REGISTERED`, `INVITATION_EXPIRED`, `EMAIL_UNVERIFIED`, `ORG_NOT_ACTIVE`, `CAPABILITY_DENIED` - 404: `NOT_FOUND`, `UNKNOWN_OPERATION`, `ROUTE_NOT_FOUND` (no route answers the path) - 405: `METHOD_NOT_ALLOWED` - 409: `IDEMPOTENCY_KEY_REUSED`, `INTAKE_KEY_REUSED`, `KEY_ALREADY_REGISTERED`, `CONNECTION_DOWN` (`POST /transfers`), `EXCEEDS_MARGIN_HEADROOM`, `HEADROOM_UNKNOWN` (a transfer's submit and its approval) - 413: `TOO_LARGE`, `PAYLOAD_TOO_LARGE`, `DOCUMENT_TOO_LARGE` - 422: a reference this member will not send: `INSTRUMENT_NOT_LIVE`, `ACCOUNT_NOT_ACTIVE` (`POST /orders`), `REFERENCE_UNKNOWN_INSTRUMENT`, `REFERENCE_INSTRUMENT_NOT_LIVE`, `REFERENCE_UNKNOWN_ACCOUNT` (an algo document); `VENUE_UNSUPPORTED`, `DEDICATED_KEY`, `DESTINATION_NOT_ALLOWED` - 428: `PRECONDITION_REQUIRED` - 429: `INBOX_FULL`, `IN_FLIGHT_FULL`, `RATE_LIMITED` - 500: `INTERRUPTED`, `INTERNAL_ERROR`, `PROJECTION_MISS` - 503: `NOT_PRIMED`, `NOT_SERVING`, `OWNER_ABSENT`, `INTAKE_UNAVAILABLE`, `BALANCES_UNAVAILABLE`, `POSITIONS_UNAVAILABLE`, `RISK_UNAVAILABLE`, `TRANSFERS_UNAVAILABLE`, `ALGOS_UNAVAILABLE`, `NOTIFICATIONS_UNAVAILABLE`, `TICKETS_UNAVAILABLE`, `REGISTRATION_PENDING`, `PROJECTION_BEHIND`, `LOST`, `REJECTED_NOT_REGISTERED`, `REJECTED_NOT_ACTIVE` The record owners' refusals ride verbatim — `OrgRegisterRejected.reason`, `OrderRejected.reason`, `AlgoRejected.reason`, `RiskLimitRejectReason`, `RiskAdjustmentRejectReason`, `ManualExecutionRejectReason`, `TransferRejectReason` and `NotificationEndpointRejected.reason` list them; the guide maps each to its status.
- `message` (string, required) — For display only; its wording may change at any time.
- `requestId` (string, required) — The request's id, also sent as X-Request-Id; quote it to support.
- `retryable` (boolean, required) — Whether sending the identical request again, its `Idempotency-Key` included, after `Retry-After` or a short pause, can succeed with nothing else changed. `false` where something must change first: the request, its key, its precondition, the caller's standing, or the platform's own records or deployment. A refusal the record owner judged is always `false`: it is the recorded answer to its key, which replays it.

### Actor

Who acted — the principal behind a command, a row's maker or its concluder: a member (USER, id = the user id), an API key the organisation issued (API_KEY, id = the API key id), or the platform itself (MACHINE, id 0 — a connector's report, an algo instance's order, the door's own write). The kind's value set is append-only: a consumer READING an unknown kind treats the actor as unknown, never as an error.

- `kind` (enum, required) — The kind of principal; which id space `id` names.
  - Allowed values: `USER`, `API_KEY`, `MACHINE`
- `id` (integer, required) — The principal's id in its kind's space: a user id, an API key id, or 0 for the platform itself.

### ApprovalItemApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, required, nullable) — When this approval was given, platform time in epoch nanoseconds as a decimal string.

### ApprovalItemApproversItem

- `userId` (integer, required) — A person who may approve.

### ApprovalImage

One of the nine row shapes a proposal lives in — an item's `before` and `after` are both this, `family` saying which. The account's is `AccountImage` — the row's members without `globalSequence`, `keys[]` carrying a key change since 0.65.0. The shapes are told apart by their required ids (an address payload fails `AccountImage`'s required `ownership`, and so on), so a generated union deserializes without a discriminator; a further family appends here once.

- Account Image: AccountImage
- Account Address Updated: AccountAddressUpdated
- Asset Policy Updated: AssetPolicyUpdated
- Chain Policy Updated: ChainPolicyUpdated
- Trading Policy Updated: TradingPolicyUpdated
- Approval Rule Updated: ApprovalRuleUpdated
- Risk Limit Row: RiskLimitRow
- Transfer Row: TransferRow
- Notification Endpoint Updated: NotificationEndpointUpdated

### AccountImage

An account as a proposal images it — the `AccountRow` members without the row extras (`globalSequence`): the record, `keys[]`, `capabilities`, `connection`, `trading`, `parentAccountId` and `readAtNs`. An `accounts` item's `before` and `after` are this; a key change (0.65.0) shows in `keys[]`.

- `accountId` (integer, required) — Sticky entity key.
- `approvals` (list of AccountUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in approval order — grown by each approval and kept on the concluded row as its record until the next proposal or a withdrawal clears it; empty until the first approval. The proposal concludes at the approval that meets the organisation's count for the family as it stands then; pendingTransition says whether one is pending. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `capabilities` (AccountCapabilitySet, required) — Derived from the keys beneath the account (`keys[]`) as enforcement reads them: `trade` is the account's own key where it trades, `transfer` its transfers key — a pending key changes nothing here until it is approved. It is derived, not decided: it changes with the keys' records and their health without the row's `version` moving, and it reads the same on both views.
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: the pending transition the conclusion cleared, as the register wrote it (KEY_CHANGE, since v21, a key's change — the key's own concludedTransition says which); NONE while it pends, or where none was. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `connection` (ConnectionReading, required, nullable) — The account's reading through the key that reads it (its own key while `ACTIVE`, else its transfers key standing in): `CONNECTING` until the first answer, then the probe's or the connector's word — `CONNECTED`, `DEGRADED` or `DOWN` with its reason (`IP_NOT_WHITELISTED`, `AUTH_FAILED`, `ACCOUNT_EXISTS` when another live account of the organisation already holds that venue account, `ACCOUNT_DISABLED`, …). A `DOWN` reading stays on the row for the member to read, and the periodic re-probe recovers it once the venue answers. Null once the account is `DELETED`.
- `displayName` (string, required) — The account's name, as a person states it. At most 64 bytes; longer refuses INVALID_FIELD.
- `keys` (list of AccountKey, required) — The account's live keys, ascending by `keyId`, never a deleted one; `GET /accounts/{id}/keys/{keyId}` serves the whole row. On the latest view each key's latest image: a change pending on the account's slot (`pendingTransition` `KEY_CHANGE`, 0.65.0) shows as the key's own transition and image — a rotation's incoming `fingerprint` and `observed`, an amend's `name`, flags and `rotateByNs` (0.70.0), an enable, a delete, a new key. On `?view=approved` each key as enforcement reads it; the two agree while nothing pends. Readings move without the row's `version`; a key change moves it.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null.
- `orgId` (integer, required) — The owning org — stamped by the owner from the maker's org, never client-supplied.
- `ownership` (enum, required) — Whose value the account holds; HOUSE unless stated otherwise. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `HOUSE`, `CLIENT_OMNIBUS`, `CLIENT_SEGREGATED`
- `parentAccountId` (integer, required, nullable) — On a sub-account, the organisation's account for the parent the key probe stated (`parentExternalRef`), else null — derived at the read, never recorded.
- `parentExternalRef` (string, required) — The venue's identifier for the account this one is a sub-account of, as the key probe stated it; empty for a main account, or until a probe answers. The organisation's row for it, where one exists, is served beside it as parentAccountId. At most 256 bytes; longer refuses INVALID_FIELD.
- `pendingTransition` (enum, required) — ACTIVATE (the connection), AMEND (a re-statement — the proposed axes ride this record while the last approved record keeps enforcing), ENABLE, DELETE, KEY_CHANGE (since v21 a change to one of the account's keys — added, amended, rotated, enabled or deleted; the key's own pendingTransition says which); NONE otherwise. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `purpose` (enum, required) — What the account is for; TREASURY unless stated otherwise. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `TREASURY`, `CLIENT_DEPOSIT`, `SETTLEMENT_OPS`, `COLLATERAL`, `HEDGE`, `RAIL_VISIBLE`
- `readAtNs` (string, required, nullable) — When the account was last read: the latest account report on the key that reads it (the account's own key while `ACTIVE`, else its transfers key standing in) — its `health.account.reportedAtNs` while `CONNECTED`, or `DEGRADED` for a reason other than `RATE_LIMITED` and `VENUE_UNAVAILABLE`, and only after the status's first report (`transitionAtNs`); `null` otherwise — `DOWN`, those two, unreported — and once `DELETED`. The one clock to age for an account: a time that stops is a connector stopped silently; `null`: the report shows no clean read, `health.account` saying why.
- `remark` (string, required) — The maker's note on the pending proposal, for its approvers; empty-not-null. At most 256 bytes; longer refuses INVALID_FIELD.
- `status` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `PENDING_APPROVAL`, `ACTIVE`, `DISABLED`, `DELETED`, `DRAFT`
- `trading` (ConnectionReading, required, nullable) — The order-entry connector's reading on the account's trading key; null when no key trades the account.
- `venueAccountRef` (string, required) — The venue's own identifier for this account (an OKX uid, a Bybit UID), filled by the first key probe that answers; empty until then. Unique among the organisation's live accounts at the venue. At most 256 bytes; longer refuses INVALID_FIELD.
- `version` (string, required) — Monotonic per entity. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded; 0 while it is pending, or when the row never carried one. A write the organisation's count let through at once concludes in the maker's own fact: equal to proposedAtNs. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded the row's last proposal: the approver whose approval met the organisation's count, or the maker when the count was 0 and the write concluded at once; null while it is pending, or when the row never carried one. an actor: an object \{kind, id}; null where none is stated
- `exchangeId` (integer, optional, nullable) — The venue the account is at — the exchange its keys are keys of.
- `keyHolder` (Actor, optional, nullable) — When an API key made the row's last proposal, the member the key's secret had last been answered to as it proposed — its last rotator then, else its issuer — kept on the concluded row with proposedBy; null when a member made the proposal, or the row never carried one. The proposal counts as this member's and the key's issuer's, whoever rotates the key afterwards: neither may approve it (SELF\_APPROVAL). an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. The three fields and lastWithdrawalReason stand until the next proposal replaces them. int64 as a decimal JSON string
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it — the proposer, or a checker returning it; null when none was. an actor: an object \{kind, id}; null where none is stated
- `portfolioId` (integer, optional, nullable) — Single assignment in the POC; 0 = unassigned.
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made, kept on the concluded row; 0 when the row never carried one. int64 as a decimal JSON string
- `proposedBy` (Actor, optional, nullable) — Who made the row's last proposal — kept on the concluded row as its record; null when the row never carried one. pendingTransition says whether that proposal is still pending. an actor: an object \{kind, id}; null where none is stated

### AccountAddressUpdated

- `accountAddressId` (integer, required) — The address's id, minted by the platform and never reused.
- `version` (string, required) — The row's version: monotonic per record, bumped on every change — served as the ETag and taken by If-Match. int64 as a decimal JSON string
- `orgId` (integer, required) — Owner-stamped from the account's org.
- `accountId` (integer, required) — The account the address belongs to.
- `assetId` (integer, required) — Refdata reference — carried, not resolved here.
- `chain` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `BITCOIN`, `ETHEREUM`
- `status` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `UNVERIFIED`, `VERIFIED`, `DELETED`
- `source` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `DECLARED`, `OBSERVED`
- `pendingTransition` (enum, required) — ACTIVATE while a declared or observed address awaits verification — the family's one proposal; NONE once verified, and on a deleted row. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: the pending transition the conclusion cleared, as the register wrote it; NONE while it pends, or where none was. So the concluded row says what concluded, however its status has moved on since. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `approvals` (list of AccountAddressUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in approval order — grown by each approval and kept on the concluded row as its record until the next proposal or a withdrawal clears it; empty until the first approval. The proposal concludes at the approval that meets the organisation's count for the family as it stands then; pendingTransition says whether one is pending. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `address` (string, required) — At most 256 bytes; longer refuses INVALID_FIELD.
- `memo` (string, required) — Memo/tag where the chain needs one; empty-not-null. At most 256 bytes; longer refuses INVALID_FIELD.
- `remark` (string, required) — The maker's note on the pending proposal, for its approvers; empty-not-null — a declaration states none today. At most 256 bytes; longer refuses INVALID_FIELD.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null.
- `proposedBy` (Actor, optional, nullable) — Who made the row's last proposal — kept on the concluded row as its record; null when the row never carried one (an address a connector observed). pendingTransition says whether that proposal is still pending. an actor: an object \{kind, id}; null where none is stated
- `keyHolder` (Actor, optional, nullable) — When an API key made the row's last proposal, the member the key's secret had last been answered to as it proposed — its last rotator then, else its issuer — kept on the concluded row with proposedBy; null when a member made the proposal, or the row never carried one. The proposal counts as this member's and the key's issuer's, whoever rotates the key afterwards: neither may approve it (SELF\_APPROVAL). an actor: an object \{kind, id}; null where none is stated
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made — the declaration or the observation — kept on the concluded row; 0 when the row never carried one. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded; 0 while it is pending, or when the row never carried one. A write the organisation's count let through at once concludes in the maker's own fact: equal to proposedAtNs. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded the row's last proposal: the approver whose approval met the organisation's count, or the maker when the count was 0 and the write concluded at once; null while it is pending, or when the row never carried one. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it — the proposer, or a checker returning it; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. The three fields and lastWithdrawalReason stand until the next proposal replaces them. int64 as a decimal JSON string
- `verifiedUnderCount` (integer, optional, nullable) — The organisation's account-addresses approval count read when the address's verification concluded, or unstated (null) where that count was 0 — an address verified on its declarer's own write, or by one person while the organisation's count was 0 — and for every address verified before this field existed. An address verified under no stated count serves only a transfer a second person approves; to spare it that, delete it and declare it again under a count of at least 1, which gives it a new id: a verified address is never re-verified.

### AssetPolicyUpdated

- `assetPolicyId` (integer, required) — Sticky entity key.
- `version` (string, required) — The row's version — monotonic per record, bumped on every change; served as the ETag and taken by If-Match. int64 as a decimal JSON string
- `orgId` (integer, required) — Owner-stamped.
- `assetId` (integer, required) — Refdata reference — carried, not resolved here.
- `status` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `DRAFT`, `PENDING_APPROVAL`, `ACTIVE`, `DELETED`
- `pendingTransition` (enum, required) — ACTIVATE, AMEND or DELETE; NONE otherwise. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: the pending transition the conclusion cleared, as the register wrote it; NONE while it pends, or where none was. So the concluded row says what concluded, however its status has moved on since. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `approvals` (list of AssetPolicyUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in approval order — grown by each approval and kept on the concluded row as its record until the next proposal or a withdrawal clears it; empty until the first approval. The proposal concludes at the approval that meets the organisation's count for the family as it stands then; pendingTransition says whether one is pending. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `remark` (string, required) — The maker's note on the pending proposal, for its approvers; empty-not-null. At most 256 bytes; longer refuses INVALID_FIELD.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null.
- `maxTicketAmount` (string, optional, nullable) — Per-transfer ticket cap; 0 = no cap. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `approvalThresholdAmount` (string, optional, nullable) — Transfers at or above this amount require an approval; 0 = every transfer requires approval (the fail-safe reading). money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `reconciliationToleranceAmount` (string, optional, nullable) — The tolerance a reconciliation comparison allows; 0 = an exact match is required (fail-safe: tighter and noisier, never looser). money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `openingGraceNs` (string, optional, nullable) — The activation grace window, held as sequenced state so every member derives the same ledger from it; 0 = no window — no observation auto-posts opening equity (the strict reading). int64 as a decimal JSON string
- `proposedBy` (Actor, optional, nullable) — Who made the row's last proposal — kept on the concluded row as its record; null when the row never carried one (a row a connector or the platform landed). pendingTransition says whether that proposal is still pending. an actor: an object \{kind, id}; null where none is stated
- `keyHolder` (Actor, optional, nullable) — When an API key made the row's last proposal, the member the key's secret had last been answered to as it proposed — its last rotator then, else its issuer — kept on the concluded row with proposedBy; null when a member made the proposal, or the row never carried one. The proposal counts as this member's and the key's issuer's, whoever rotates the key afterwards: neither may approve it (SELF\_APPROVAL). an actor: an object \{kind, id}; null where none is stated
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made, kept on the concluded row; 0 when the row never carried one. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded; 0 while it is pending, or when the row never carried one. A write the organisation's count let through at once concludes in the maker's own fact: equal to proposedAtNs. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded the row's last proposal: the approver whose approval met the organisation's count, or the maker when the count was 0 and the write concluded at once; null while it is pending, or when the row never carried one. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it — the proposer, or a checker returning it; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. The three fields and lastWithdrawalReason stand until the next proposal replaces them. int64 as a decimal JSON string
- `approvalAggregateAmount` (string, optional, nullable) — The organisation's rolling 24-hour sum of this asset's on-chain transfers, the one being judged included, at or above which every transfer needs the transfers approval count whatever its own size; 0 = no aggregate. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset

### ChainPolicyUpdated

- `chainPolicyId` (integer, required) — Sticky entity key.
- `version` (string, required) — The row's version — monotonic per record, bumped on every change; served as the ETag and taken by If-Match. int64 as a decimal JSON string
- `orgId` (integer, required) — Owner-stamped.
- `assetId` (integer, required) — Refdata reference.
- `chain` (enum, required) — ≠ UNKNOWN on a policy row. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `BITCOIN`, `ETHEREUM`
- `status` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `DRAFT`, `PENDING_APPROVAL`, `ACTIVE`, `DELETED`
- `pendingTransition` (enum, required) — NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: the pending transition the conclusion cleared, as the register wrote it; NONE while it pends, or where none was. So the concluded row says what concluded, however its status has moved on since. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `approvals` (list of ChainPolicyUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in approval order — grown by each approval and kept on the concluded row as its record until the next proposal or a withdrawal clears it; empty until the first approval. The proposal concludes at the approval that meets the organisation's count for the family as it stands then; pendingTransition says whether one is pending. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `remark` (string, required) — The maker's note on the pending proposal, for its approvers; empty-not-null. At most 256 bytes; longer refuses INVALID_FIELD.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null.
- `isEnabled` (boolean, optional) — FALSE = chain disabled for this asset: an unstated chain moves nothing. a boolean; absent reads false
- `minConfirmations` (integer, optional, nullable) — The settle gate: the confirmation depth at which an on-chain transfer counts as settled rather than in transit; 0 = not stated, and a transfer never settles (the strict reading).
- `minTransferAmount` (string, optional, nullable) — 0 = no bound. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `maxTransferAmount` (string, optional, nullable) — 0 = no bound. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `settlementSlaNs` (string, optional, nullable) — The obligation's value-date offset (value date = the envelope time plus this); 0 = due immediately, so breaches surface at once (the noisy-safe reading). int64 as a decimal JSON string
- `proposedBy` (Actor, optional, nullable) — Who made the row's last proposal — kept on the concluded row as its record; null when the row never carried one (a row a connector or the platform landed). pendingTransition says whether that proposal is still pending. an actor: an object \{kind, id}; null where none is stated
- `keyHolder` (Actor, optional, nullable) — When an API key made the row's last proposal, the member the key's secret had last been answered to as it proposed — its last rotator then, else its issuer — kept on the concluded row with proposedBy; null when a member made the proposal, or the row never carried one. The proposal counts as this member's and the key's issuer's, whoever rotates the key afterwards: neither may approve it (SELF\_APPROVAL). an actor: an object \{kind, id}; null where none is stated
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made, kept on the concluded row; 0 when the row never carried one. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded; 0 while it is pending, or when the row never carried one. A write the organisation's count let through at once concludes in the maker's own fact: equal to proposedAtNs. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded the row's last proposal: the approver whose approval met the organisation's count, or the maker when the count was 0 and the write concluded at once; null while it is pending, or when the row never carried one. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it — the proposer, or a checker returning it; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. The three fields and lastWithdrawalReason stand until the next proposal replaces them. int64 as a decimal JSON string
- `maxFeeAmount` (string, optional, nullable) — The fee allowance an on-chain transfer of this asset over this chain reserves beside its amount, in the asset feeAssetId names, and the ceiling a venue's quoted fee is refused above; 0 = no allowance — the transfer reserves its amount alone and no quoted fee is refused. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `feeAssetId` (integer, optional, nullable) — The asset the venue charges an on-chain transfer's fee in — the one maxFeeAmount is stated in; 0 = the moved asset.

### TradingPolicyUpdated

- `tradingPolicyId` (integer, required) — Sticky entity key.
- `version` (string, required) — The row's version — monotonic per record, bumped on every change; orders record which version governed them. int64 as a decimal JSON string
- `orgId` (integer, required) — Owner-stamped.
- `status` (enum, required) — UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `DRAFT`, `PENDING_APPROVAL`, `ACTIVE`, `DELETED`
- `pendingTransition` (enum, required) — ACTIVATE, AMEND, DELETE or RESUME_TRADING; NONE otherwise. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: the pending transition the conclusion cleared, as the register wrote it; NONE while it pends, or where none was. So the concluded row says what concluded, however its status has moved on since. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `approvals` (list of TradingPolicyUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in approval order — grown by each approval and kept on the concluded row as its record until the next proposal or a withdrawal clears it; empty until the first approval. The proposal concludes at the approval that meets the organisation's count for the family as it stands then; pendingTransition says whether one is pending. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `remark` (string, required) — The maker's note on the pending proposal, for its approvers; empty-not-null. At most 256 bytes; longer refuses INVALID_FIELD.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null.
- `instrumentId` (string, optional, nullable) — The refdata instrument — carried, not resolved here; 0 on the wire, null in the API, on the organisation-wide default row. int64 as a decimal JSON string
- `isTradingHalted` (boolean, optional) — The halt: true on the organisation-wide default row halts the organisation; true on a per-instrument row halts that instrument. False is the decode default — but no order is admitted without an ACTIVE policy row at all: the real gate is the row's existence. a boolean; absent reads false
- `maxOrderQty` (string, optional, nullable) — Per-order quantity cap; 0 = no cap. The organisation-wide default row has no scale context — a non-zero value on it is refused INVALID_FIELD. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `maxOrderNotional` (string, optional, nullable) — Per-order notional cap; 0 = no cap; refused non-zero on org-default rows as maxOrderQty. money (a Decimal on the wire: a scaled integer with its own scale), served as an exact decimal string at the value's own scale — every fractional digit that scale states, trailing zeros included; never raw; null when the 0 sentinel means unset
- `priceCollarBps` (integer, optional, nullable) — The limit-price collar against the market-data top-of-book reference; 0 = no collar — the reference-freshness gate still applies unconditionally, since the reference is mandatory.
- `refFreshnessNs` (string, optional, nullable) — How fresh the top-of-book reference must be at admission (the NO_REFERENCE_PRICE gate); 0 disables the age comparison alone — the reference itself stays mandatory for every order type, so an absent reference refuses either way. int64 as a decimal JSON string
- `instructFreshnessNs` (string, optional, nullable) — How stale an accepted but never instructed order may be when it reaches the venue: past it the connector never places it and the order disposes toward INSTRUCTION_EXPIRED. 0 = the connector's configured default window, never a lockout. int64 as a decimal JSON string
- `degradedGraceNs` (string, optional, nullable) — The admission tolerance for a degraded connection: an order-entry credential whose connection has been DEGRADED for no longer than this still admits; DOWN always refuses, and a cancel never gates. 0 = any DEGRADED refuses (the strict reading). Measured from the health fact's envelope time, so every member agrees. int64 as a decimal JSON string
- `maxOpenOrders` (integer, optional, nullable) — Open-order ceiling; 0 = none. Counted over the organisation's open orders as a whole: the tighter of the governing row's and the organisation-wide default row's stated ceilings binds. A per-instrument row's ceiling is not yet scoped to its instrument.
- `maxOrdersPerMinute` (integer, optional, nullable) — Entry-rate ceiling per tumbling minute of stream time, enforced at the orders owner; 0 = no ceiling. Counted over the organisation's accepted orders in the minute: the tighter of the governing row's and the organisation-wide default row's stated ceilings binds, as maxOpenOrders does.
- `proposedBy` (Actor, optional, nullable) — Who made the row's last proposal — kept on the concluded row as its record; null when the row never carried one (a row a connector or the platform landed). pendingTransition says whether that proposal is still pending. an actor: an object \{kind, id}; null where none is stated
- `keyHolder` (Actor, optional, nullable) — When an API key made the row's last proposal, the member the key's secret had last been answered to as it proposed — its last rotator then, else its issuer — kept on the concluded row with proposedBy; null when a member made the proposal, or the row never carried one. The proposal counts as this member's and the key's issuer's, whoever rotates the key afterwards: neither may approve it (SELF\_APPROVAL). an actor: an object \{kind, id}; null where none is stated
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made, kept on the concluded row; 0 when the row never carried one. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded; 0 while it is pending, or when the row never carried one. A write the organisation's count let through at once concludes in the maker's own fact: equal to proposedAtNs. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded the row's last proposal: the approver whose approval met the organisation's count, or the maker when the count was 0 and the write concluded at once; null while it is pending, or when the row never carried one. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it — the proposer, or a checker returning it; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. The three fields and lastWithdrawalReason stand until the next proposal replaces them. int64 as a decimal JSON string

### ApprovalRuleUpdated

- `approvalRuleId` (integer, required) — Sticky entity key.
- `version` (string, required) — Monotonic per entity. int64 as a decimal JSON string
- `orgId` (integer, required) — Owner-stamped.
- `family` (enum, required) — The family the rule governs; one rule per organisation and family. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `ACCOUNTS`, `ACCOUNT_ADDRESSES`, `ASSET_POLICIES`, `CHAIN_POLICIES`, `TRADING_POLICIES`, `RISK`, `TRANSFERS`, `NOTIFICATIONS`
- `count` (integer, required) — Approvals a proposal in the family needs: 0 (the default) = the maker's own write concludes it, 1 = one other user's approval, up to 4 — account addresses included since v16, their verifications being the approvals. uint8: an integer 0..255
- `pendingTransition` (enum, required) — AMEND while a lowering of the count waits for a second org:manage holder; NONE otherwise. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: the pending transition the conclusion cleared, as the register wrote it; NONE while it pends, or where none was. So the concluded row says what concluded, however its status has moved on since. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`, `RESUME_TRADING`, `KEY_CHANGE`
- `approvals` (list of ApprovalRuleUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in approval order — grown by each approval and kept on the concluded row as its record until the next proposal or a withdrawal clears it; empty until the first approval. The proposal concludes at the approval that meets the organisation's count for the family as it stands then; pendingTransition says whether one is pending. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `remark` (string, required) — The maker's note on the pending proposal, for its approvers; empty-not-null. At most 256 bytes; longer refuses INVALID_FIELD.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null, and empty when a raise or restatement replaced it.
- `proposedBy` (Actor, optional, nullable) — Who made the row's last proposal — kept on the concluded row as its record; null when the row never carried one (a row a connector or the platform landed). pendingTransition says whether that proposal is still pending. an actor: an object \{kind, id}; null where none is stated
- `keyHolder` (Actor, optional, nullable) — When an API key made the row's last proposal, the member the key's secret had last been answered to as it proposed — its last rotator then, else its issuer — kept on the concluded row with proposedBy; null when a member made the proposal, or the row never carried one. The proposal counts as this member's and the key's issuer's, whoever rotates the key afterwards: neither may approve it (SELF\_APPROVAL). an actor: an object \{kind, id}; null where none is stated
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made, kept on the concluded row; 0 when the row never carried one. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded; 0 while it is pending, or when the row never carried one. A write the organisation's count let through at once concludes in the maker's own fact: equal to proposedAtNs. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded the row's last proposal: the approver whose approval met the organisation's count, or the maker when the count was 0 and the write concluded at once; null while it is pending, or when the row never carried one. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it — the proposer, a holder returning it, or the holder whose raise or restatement replaced it; null when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. The three fields and lastWithdrawalReason stand until the row's next write: a new lowering replaces them, and a raise or restatement made with nothing pending clears them with the rest of the record. int64 as a decimal JSON string

### RiskLimitRow

One risk limit: the organisation-wide default row (`accountId` 0) or an account's own, its seven thresholds — leverage ratios to the margin equity, each soft (past it the account is held to reducing its risk) and hard (past it, blocked), and a margin-equity floor in USD — at eight decimal places, and its maker-checker proposal. A proposal that only tightens is in force at once; one that loosens any threshold, judged against what governs the account now, collects the organisation's `risk` approvals. Orders enforce them through the account's posture (`GET /risk/postures`).

- `riskLimitId` (integer, required) — The row's id.
- `version` (string, required) — The row's version as a decimal string, bumped by every change, the `ETag` an entity write's `If-Match` takes.
- `accountId` (integer, required) — The account the row governs (`GET /accounts`); `0` is the organisation-wide default row, which governs every account without a row of its own and every threshold such a row leaves unstated.
- `status` (enum, required) — `PENDING_APPROVAL`: a first proposal not yet approved, or withdrawn — it governs nothing. `ACTIVE`: in force. `RETIRED`: retired, the default governs again. The value set is append-only: read an unknown value as `UNKNOWN`.
  - Allowed values: `UNKNOWN`, `PENDING_APPROVAL`, `ACTIVE`, `RETIRED`
- `grossLeverageNoSpotSoft` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): Gross leverage over derivatives and their resting orders past which the account is held to reducing its risk, as a ratio to the margin equity (`"3"` is 3x). `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `grossLeverageNoSpotHard` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): Gross leverage over derivatives and their resting orders past which the account is blocked. `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `netLeverageNoSpotSoft` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): Net leverage over derivatives and their resting orders past which the account is held to reducing its risk. `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `netLeverageNoSpotHard` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): Net leverage over derivatives and their resting orders past which the account is blocked. `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `grossLeverageWithSpotSoft` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): Gross leverage with the coins held and every resting order past which the account is held to reducing its risk. `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `grossLeverageWithSpotHard` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): Gross leverage with the coins held and every resting order past which the account is blocked. `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `marginEquityFloorUsd` (string, required, nullable) — money (an exact decimal string at the scale the row holds it, trailing zeros included): The margin equity in USD (`marginEquityUsd` on the risk record: the equity of the account's margin wallets — at Binance the spot and USD-M wallets together — not the account's whole NLV) at or under which the account is blocked. `"0"` is no cap; `null` is not stated, which on an account's row means the organisation-wide default's value applies.
- `proposedBy` (Actor, required, nullable) — The maker of the row's last proposal — an actor, kept on the record once it concludes or is withdrawn; `null` when the row has had none (the organisation-wide default the platform creates). Always a member's: only members write risk. `pendingTransition` alone says whether a proposal is pending.
- `pendingTransition` (enum, required) — What the pending proposal proposes: `ACTIVATE` a first row, `AMEND` new thresholds on an active row, `RETIRE` its retirement; `NONE` when nothing is pending. On `view=latest` the thresholds are the proposed ones while it is pending; `view=approved` shows those in force.
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `RETIRE`
- `proposedAtNs` (string, required, nullable) — When the row's last proposal was made, epoch nanoseconds as a decimal string; `null` when none was.
- `concludedAtNs` (string, required, nullable) — When the row's last proposal concluded, epoch nanoseconds as a decimal string — equal to `proposedAtNs` on one that only tightened and so concluded as it was submitted; `null` while it is pending, after a withdrawal, and on a row that has had none.
- `concludedBy` (Actor, required, nullable) — Who concluded it — the approver whose approval met the organisation's `risk` rule in force, or the maker where nothing needed approving; `null` when `concludedAtNs` is.
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded — `ACTIVATE`, `AMEND` or `RETIRE`, however the row's `status` has moved on since; `NONE` while it is pending, after a withdrawal, and on a row that has had none. The value set is append-only: treat an unknown name as unknown, never as an error.
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `RETIRE`
- `approvals` (list of RiskLimitRowApprovalsItem, required) — Who approved the row's last proposal and when, in approval order; empty until the first approval and after a withdrawal. It concludes when they number the organisation's `risk` rule in force at that approval (`GET /approval-rules?family=RISK`).
- `remark` (string, required) — The maker's note on the last proposal; empty when none.
- `lastWithdrawalProposedBy` (Actor, required, nullable) — Who made the last withdrawn proposal; `null` when none was.
- `lastWithdrawalWithdrawnBy` (Actor, required, nullable) — Who withdrew it — its maker, or an approver returning it; `null` when none was.
- `lastWithdrawalAtNs` (string, required, nullable) — When it was withdrawn, epoch nanoseconds as a decimal string; `null` when none was.
- `lastWithdrawalReason` (string, required) — Why it was withdrawn, as the withdrawer stated it; empty when none.
- `updatedAtNs` (string, required) — When this version was written, epoch nanoseconds as a decimal string.
- `updatedBy` (Actor, required) — Who wrote this version, never `null`: a member, or the platform itself — `MACHINE` with id `0` — on the default row every organisation is given, every threshold `"0"`.
- `globalSequence` (string, optional) — The position as a decimal string — the last change this member had applied, orders, balance readings and algo instances included.

### TransferRow

One transfer: an amount of one asset moving from one account's wallet to another's — where it stands, what the venue and the destination have reported, and its proposal record: the submit while it awaits approval, a resolution by hand while that does. Every version is the whole record.

- `transferId` (string, required) — The transfer's id, a 64-bit integer as decimal digits.
- `version` (string, required) — The transfer's version as a decimal string: 1 at the submit, one more on every change; its `ETag`, which an approval, a withdrawal and a resolution state as `If-Match`.
- `status` (enum, required) — `PENDING_APPROVAL`: submitted, awaiting a second person. `QUEUED`: admitted, waiting for the venue. `INSTRUCTED`: the venue accepted it. `PENDING_PROVIDER_APPROVAL`: the custodian's own approvers must act. `IN_TRANSIT`: broadcast on its chain. `SETTLED`, `FAILED`, `WITHDRAWN`: closed. `RESOLVED_SETTLED`, `RESOLVED_FAILED`: closed by hand. The value set is append-only: read an unknown value as `UNKNOWN`.
  - Allowed values: `UNKNOWN`, `PENDING_APPROVAL`, `QUEUED`, `INSTRUCTED`, `PENDING_PROVIDER_APPROVAL`, `IN_TRANSIT`, `SETTLED`, `FAILED`, `WITHDRAWN`, `RESOLVED_SETTLED`, `RESOLVED_FAILED`
- `transition` (enum, required) — What this version records: the `SUBMIT`; an `APPROVE` counted, or the one that admitted it (`QUEUE`); a `WITHDRAW`; the venue's `INSTRUCT`, `PROVIDER_HOLD` and `PROVIDER_RELEASE`; an `OBSERVE` — a broadcast, more confirmations, a deposit seen and held; `ARRIVE`, `SETTLE`, `FAIL`; `SLA_BREACH` — it went overdue; a `RESOLVE` proposed, approved or concluded; `CONTRADICT`; `RISK_HOLD` and `RISK_RELEASE`. Append-only: read an unknown value as `UNKNOWN`.
  - Allowed values: `UNKNOWN`, `SUBMIT`, `APPROVE`, `WITHDRAW`, `QUEUE`, `INSTRUCT`, `PROVIDER_HOLD`, `PROVIDER_RELEASE`, `OBSERVE`, `ARRIVE`, `SETTLE`, `FAIL`, `SLA_BREACH`, `RESOLVE`, `CONTRADICT`, `RISK_HOLD`, `RISK_RELEASE`
- `sourceAccountId` (integer, required) — The account the value leaves (`GET /accounts`).
- `sourceWallet` (string, required) — The wallet the value leaves, as the venue names it — `funding`, `trading`, a vault's wallet.
- `destAccountId` (integer, required) — The account the value reaches — the source account on a move between two of its wallets.
- `destWallet` (string, required) — The wallet the value reaches, as the venue names it.
- `assetId` (integer, required) — The asset moved.
- `chain` (enum, required, nullable) — The network an on-chain transfer settles on; `null` for a move between two wallets of one account, which crosses none. `UNKNOWN`: an on-chain transfer on a network this member cannot name yet — it runs a build older than the network — never a move between two wallets. The value set is append-only: a name you do not know is still a network.
  - Allowed values: `UNKNOWN`, `BITCOIN`, `ETHEREUM`
- `amount` (string, required) — money (an exact decimal string at the scale the submit stated it): the amount instructed, in the asset's own units. The fee is not inside it.
- `feeAmount` (string, required, nullable) — money (an exact decimal string at the scale it was stated at): the fee the venue stated, in the asset `feeAssetId` names; `null` until the venue states one.
- `feeAssetId` (integer, required) — The asset `feeAmount` is stated in: the fee asset named by the chain policy the transfer was admitted under — the moved asset where that policy names none, and for a move between two wallets of one account. Stated on every row, whether or not the venue has stated a fee yet; it moves only if an approval admits the transfer under a chain policy amended since the submit.
- `settledAmount` (string, required, nullable) — money (an exact decimal string at the scale it was stated at): what the destination credited, net of fees; `null` until the destination reports a credit — or, on a transfer resolved `SETTLED` by hand, until that resolution is approved.
- `confirmations` (integer, required) — The highest confirmation count either end of the transfer has reported; 0 until one is.
- `executingCredentialId` (integer, required) — The key that executes the transfer (`GET /accounts/{id}/keys`): the account's own key for a move between its wallets, the source account's transfers key for an on-chain one.
- `destAddressId` (integer, required, nullable) — The destination's verified address the transfer was admitted to (`GET /account-addresses`); `null` for a move between two wallets.
- `externalRef` (string, required) — The venue's own id for the withdrawal or transfer, once it accepted it; empty until then.
- `txId` (string, required) — The on-chain transaction hash, once broadcast or stated by an approved resolution; empty otherwise.
- `failureReason` (enum, required) — Why the transfer failed. The venue's refusal by name — `INSUFFICIENT_FUNDS`, `ADDRESS_NOT_ALLOWLISTED`, `BELOW_MINIMUM`, `ABOVE_LIMIT`, `ASSET_SUSPENDED`, `PERMISSION_DENIED`, `PROVIDER_DENIED` — or the platform's own before it instructed the venue: `AMOUNT_PRECISION` (an amount the venue's precision cannot carry), `FEE_ABOVE_POLICY` (the venue's fee above the chain policy's `maxFeeAmount`); else `VENUE_ERROR` or `TIMEOUT`. `UNKNOWN` while it has not failed. Append-only.
  - Allowed values: `UNKNOWN`, `INSUFFICIENT_FUNDS`, `ADDRESS_NOT_ALLOWLISTED`, `BELOW_MINIMUM`, `ABOVE_LIMIT`, `ASSET_SUSPENDED`, `PERMISSION_DENIED`, `PROVIDER_DENIED`, `AMOUNT_PRECISION`, `FEE_ABOVE_POLICY`, `VENUE_ERROR`, `TIMEOUT`
- `failureDetail` (string, required) — The venue's own text behind `failureReason`; empty unless it failed.
- `isOverdue` (boolean, required) — Whether the transfer's current leg has run past its deadline (`slaDeadlineNs`); cleared when the leg advances. An overdue `QUEUED` or `PENDING_PROVIDER_APPROVAL` transfer may be resolved by hand.
- `overdueLeg` (enum, required) — The leg that went overdue: `ACTION` — the venue's acceptance, or a move between two wallets; `PROVIDER` — the custodian's own approvers; `CHAIN` — from the instruction to the destination first seeing the deposit; `HELD` — a deposit seen at its destination and not yet credited. `UNKNOWN` while on time.
  - Allowed values: `UNKNOWN`, `ACTION`, `PROVIDER`, `CHAIN`, `HELD`
- `slaLeg` (enum, required) — The leg whose deadline is running now, as `overdueLeg` names them; `UNKNOWN` while the transfer awaits approval and once it is closed.
  - Allowed values: `UNKNOWN`, `ACTION`, `PROVIDER`, `CHAIN`, `HELD`
- `slaDeadlineNs` (string, required, nullable) — When the running leg's deadline falls, epoch nanoseconds; `null` when none runs.
- `isHeldAtDestination` (boolean, required) — Whether the destination shows the deposit but has not credited it yet; `holdDetail` says why, where the venue does.
- `holdDetail` (string, required) — The destination's own text behind a held deposit; empty when none.
- `isFeeAbovePolicy` (boolean, required) — Whether the fee the venue charged exceeded the chain policy's `maxFeeAmount`.
- `isHeadroomAcknowledged` (boolean, required) — Whether the submit overrode the headroom check: its maker stated `acknowledgeHeadroom` and the check refused the move without it — capital taken out of a margin wallet knowingly. Each approval states its own in `approvals`.
- `isRiskHeld` (boolean, required) — Whether the transfer, queued out of a margin wallet, is held because its account's posture is `BLOCKED` (`GET /risk/postures`): nothing instructs the venue until the posture leaves `BLOCKED`. Its deadline keeps running.
- `isContradicted` (boolean, required) — Whether the venue completed or failed this transfer after it was resolved by hand; the status is unchanged.
- `assetPolicyVersion` (string, required) — The version of the organisation's asset policy the transfer was admitted under (`GET /asset-policies`) — at the submit, or at the approval that admitted it.
- `chainPolicyVersion` (string, required, nullable) — The version of the chain policy it was admitted under (`GET /chain-policies`); `null` for a move between two wallets, which reads none.
- `clientTransferId` (string, required) — The submit's `Idempotency-Key`, the caller's own handle for the transfer: taken while the transfer is open and for 24 hours after it closes.
- `submittedAtNs` (string, required) — When it was submitted, epoch nanoseconds; never moves.
- `submittedBy` (Actor, required) — Who submitted it — the one principal whose later submit under `clientTransferId` is a retry of this transfer.
- `queuedAtNs` (string, required, nullable) — When it became `QUEUED`, epoch nanoseconds; `null` before.
- `instructedAtNs` (string, required, nullable) — When the venue accepted the instruction, epoch nanoseconds; `null` before.
- `heldAtNs` (string, required, nullable) — When the destination first reported the deposit held, epoch nanoseconds; `null` if it never did.
- `settledAtNs` (string, required, nullable) — When the transfer settled — by the venue's word, the destination's credit or an approved resolution — epoch nanoseconds; `null` before.
- `proposedBy` (Actor, required) — The maker of the transfer's last proposal — the submit, or a resolution — kept once it concludes or is withdrawn.
- `pendingTransition` (enum, required) — What awaits approval: `SUBMIT` — the transfer itself, while `PENDING_APPROVAL`; `RESOLVE` — a resolution by hand, whose content is `resolveOutcome`, `evidenceKind`, `evidence`, `proposedSettledAmount` and `proposedTxId`; `UNKNOWN` when nothing does. The inbox (`GET /approvals`) lists the two as `ACTIVATE` and `AMEND`.
  - Allowed values: `UNKNOWN`, `SUBMIT`, `RESOLVE`
- `proposedAtNs` (string, required, nullable) — When the last proposal was made, epoch nanoseconds.
- `concludedAtNs` (string, required, nullable) — When the last proposal concluded, epoch nanoseconds — at the submit itself where nothing needed approving; `null` while it pends and after a withdrawal.
- `concludedBy` (Actor, required, nullable) — Who concluded it — the maker where nothing needed approving, else the approver whose approval met the count; `null` when `concludedAtNs` is.
- `concludedTransition` (enum, required) — What the last proposal proposed, kept once it concluded: `SUBMIT` or `RESOLVE`; `UNKNOWN` while it pends, or when it was withdrawn.
  - Allowed values: `UNKNOWN`, `SUBMIT`, `RESOLVE`
- `approvals` (list of TransferRowApprovalsItem, required) — Who approved the transfer's last proposal and when, in approval order; empty until the first approval. A submit concludes when they number the organisation's `transfers` rule in force at that approval (`GET /approval-rules?family=TRANSFERS`); a resolution needs at least one, whatever the rule.
- `remark` (string, required) — The maker's note on the submit, for its approvers; empty when none — and once a resolution by hand is proposed, whose maker's words are `evidence`.
- `lastWithdrawalProposedBy` (Actor, required, nullable) — Who made the last withdrawn proposal; `null` when none was.
- `lastWithdrawalWithdrawnBy` (Actor, required, nullable) — Who withdrew it — the maker, or an approver; `null` when none was.
- `lastWithdrawalAtNs` (string, required, nullable) — When it was withdrawn, epoch nanoseconds; `null` when none was.
- `lastWithdrawalReason` (string, required) — Why it was withdrawn, as the withdrawer stated it; empty when none was.
- `resolveOutcome` (enum, required) — What a resolution by hand proposes while it pends, or closed the transfer as once approved; `UNKNOWN` when none was ever proposed.
  - Allowed values: `UNKNOWN`, `SETTLED`, `FAILED`
- `evidenceKind` (enum, required) — What the resolution rests on: `VENUE_SETTLED` — the venue shows the transfer complete; `VENUE_CANCELLED`, `VENUE_FAILED`; `VENUE_NO_RECORD` — the venue holds nothing under the transfer's reference. `UNKNOWN` when no resolution was proposed.
  - Allowed values: `UNKNOWN`, `VENUE_SETTLED`, `VENUE_CANCELLED`, `VENUE_FAILED`, `VENUE_NO_RECORD`
- `evidence` (string, required) — What the resolution's maker saw at the venue, in their words; empty when none was proposed.
- `proposedSettledAmount` (string, required, nullable) — money (an exact decimal string at the scale it was stated at): what a pending `SETTLED` resolution states arrived, applied to `settledAmount` when it is approved; `null` when it states none — the destination's own figure stands, else the whole amount — and when no resolution pends.
- `proposedTxId` (string, required) — The transaction hash a pending resolution states, applied to `txId` when it is approved; empty when it states none.
- `updatedAtNs` (string, required) — When this version was written, epoch nanoseconds.
- `updatedBy` (Actor, required) — Who produced this version: the principal behind a submit, an approval, a withdrawal or a resolution — or the platform (`MACHINE`) on a venue's report, a deadline passing or a risk hold.
- `globalSequence` (string, optional) — The position as a decimal string — the last change this member had applied, orders, balance readings and algo instances included.

### NotificationEndpointUpdated

- `endpointId` (integer, required) — Sticky entity key.
- `version` (string, required) — The row's version - monotonic, bumped on every change. int64 as a decimal JSON string
- `orgId` (integer, required) — The organisation the endpoint belongs to.
- `status` (enum, required) — PENDING_APPROVAL until the endpoint's first proposal concludes - approved by another member, or made by the organisation's one member - then ACTIVE, the one status notifications are sent in, then DELETED. A first proposal that was withdrawn leaves the row PENDING_APPROVAL with nothing pending. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `PENDING_APPROVAL`, `ACTIVE`, `DELETED`
- `format` (enum, required) — What the destination is sent: SLACK is a Slack message, posted to a Slack incoming-webhook URL. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `SLACK`
- `minSeverity` (enum, required) — The least urgent event the endpoint is sent: INFO sends every event, WARNING leaves INFO out, CRITICAL sends CRITICAL alone. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `INFO`, `WARNING`, `CRITICAL`
- `events` (list of enum, required) — The event types the endpoint is sent; never empty. a set (SBE bit-set) served as the array of its published names, each a `NotificationEvent`, in declared order; empty = none set, never null; as input a repeated name refuses 400
  - Allowed values: `algo.instance.state_changed`, `algo.halted`, `algo.instance.config_refused`, `algo.instance.config_applied`, `algo.instance.version_moved`
- `pendingTransition` (enum, required) — ACTIVATE or AMEND while a proposal waits for approval; NONE otherwise. While an AMEND waits, notifications are still sent as last approved. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `DELETE`
- `concludedTransition` (enum, required) — What the row's last proposal proposed, kept once it concluded: ACTIVATE, AMEND or DELETE; NONE while it pends or when it was withdrawn. NONE is the unset sentinel: outputs only — as input the field is required, and explicit NONE refuses 400. A consumer READING this field treats an unknown name as NONE, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `NONE`, `ACTIVATE`, `AMEND`, `DELETE`
- `updatedAtNs` (string, required) — Platform time of this version. int64 as a decimal JSON string
- `updatedBy` (Actor, required) — The member behind this version. an actor: an object \{kind, id}
- `algoInstances` (list of NotificationEndpointUpdatedAlgoInstancesItem, required) — The algo instances the endpoint is sent events about; empty = every instance of the organisation. It narrows the events that name an instance: one that names none - the organisation-wide halt - is sent whatever this list holds. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `approvals` (list of NotificationEndpointUpdatedApprovalsItem, required) — Who approved the row's last proposal and when, in order. A proposal that waits concludes when the count reaches the organisation's notifications approval rule, and never before one approval; the list is empty where the proposal concluded as it was made - its maker the organisation's one member, or a deletion. a repeating group served as an array of objects, in the group's own order; empty = no entries, never null
- `name` (string, required) — The endpoint's name, as its organisation lists it - 1 to 128 bytes of UTF-8.
- `urlFingerprint` (string, required) — The destination URL's fingerprint as the gateway computed it when the URL was stored - enough to tell two URLs apart, never enough to rebuild one: fp- and sixteen lowercase hexadecimal digits.
- `host` (string, required) — The destination's host name alone - no scheme, port or path - at most 253 characters of lowercase letters, digits, dot and hyphen.
- `remark` (string, required) — The maker's note on the last proposal, for its approvers; empty-not-null. At most 256 bytes of UTF-8.
- `lastWithdrawalReason` (string, required) — Why the last proposal was withdrawn, as the withdrawer stated it; empty-not-null.
- `proposedBy` (Actor, optional, nullable) — The maker of the row's last proposal, kept after it concludes or is withdrawn - an approver is checked to be someone else while it pends. pendingTransition alone says whether a proposal pends. an actor: an object \{kind, id}; null where none is stated
- `proposedAtNs` (string, optional, nullable) — Platform time the row's last proposal was made. int64 as a decimal JSON string
- `concludedAtNs` (string, optional, nullable) — Platform time the row's last proposal concluded - equal to proposedAtNs where it concluded as it was made; 0 while it pends or when it was withdrawn. int64 as a decimal JSON string
- `concludedBy` (Actor, optional, nullable) — Who concluded it - the approver whose approval met the count, or the maker where it concluded as it was made; unstated when concludedAtNs is 0. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalProposedBy` (Actor, optional, nullable) — Who made the last proposal that was withdrawn; unstated when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalWithdrawnBy` (Actor, optional, nullable) — Who withdrew it - its maker, another member returning it, or the member whose deletion replaced it; unstated when none was. an actor: an object \{kind, id}; null where none is stated
- `lastWithdrawalAtNs` (string, optional, nullable) — Platform time of that withdrawal; 0 when none was. int64 as a decimal JSON string

### AccountUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, optional, nullable) — Platform time of the approval. int64 as a decimal JSON string

### AccountCapabilitySet

One venue account is one row, with at most one key per role beneath it; each capability names the key that holds the role, or is null when no key does.

- `trade` (AccountCapability, required, nullable) — The key this account's orders instruct through, or null when the account's key does not trade — an account nothing can trade. Its `health` is that key's order-entry reading.
- `transfer` (AccountCapability, required, nullable) — The key this account's transfers execute through, or null when no transfers key is beneath the account — can't transfer: add one. Its `health` is that key's account reading: the account connector executes transfers.

### ConnectionReading

A reading beside a status: the venue's word through one key, and when it was last read cleanly.

- `status` (enum, required) — `CONNECTING` before any answer; then the key probe's verdict; then the connector's `ConnectionHealth.status` — all but the report that opens a lane's outage with a dial (`DOWN` with reason `STARTUP`, its `transitionAtNs` and `reportedAtNs` equal), which counts as none while the probe's verdict is clean or absent — a refused probe gets no such grace, its readings being `DOWN` either way; every later report counts, a redial's `STARTUP` included, and the key's own `health` keeps every report. The value set is append-only: treat an unknown name as `UNKNOWN`.
  - Allowed values: `CONNECTING`, `UNKNOWN`, `CONNECTED`, `DEGRADED`, `DOWN`
- `reason` (string, required) — A `HealthReason` name; `NONE` while nothing is wrong.
- `readAtNs` (string, required, nullable) — When the venue was last read cleanly through this key, by the same rule as the row's `readAtNs`; null until a report shows a clean read.

### AccountKey

One key beneath an account: its name, the roles and flags it holds, its lifecycle, each connector role's reading, what the probe observed, its rotation deadline and two audit handles — never the material or the store's reference. Since 0.70.0 the entry carries every field `PUT /accounts/{id}/keys/{keyId}` moves — `name`, `canReadBalances`, `canServeAddresses`, `rotateByNs` joining `trade` — on the image the view serves, so an approver reads a key change in the inbox item's two images without `venue-keys:read`; the key's own row stays that grant's.

- `keyId` (integer, required) — The key's id — `credentialId` on its own row.
- `version` (string, required) — The key's own version, as a decimal string — what a write to the key (`PUT /accounts/{id}/keys/{keyId}`, its `/rotate`, `/enable`, `/delete`, `/disable`) names in `If-Match`; the account row's `ETag` is the account's version, not this (0.65.0).
- `name` (string, required) — The key's name, unique among your organisation's live keys — what `PUT /accounts/{id}/keys/{keyId}` renames; on the latest view a pending rename's new name, on `?view=approved` the enforced one (0.70.0).
- `trade` (boolean, required) — Whether the key may place orders for the account.
- `transfer` (boolean, required) — Whether the key executes transfers out of the account — a dedicated key, which never trades.
- `canReadBalances` (boolean, required) — Whether the key reads the account's balances — `true` on every exchange key the gateway has created since every exchange key read (the create and the amend set it); a key pinned before that keeps its stated flag, which an amend restates (0.70.0).
- `canServeAddresses` (boolean, required) — Whether the key serves the account's deposit addresses — a flag an amend moves, so a change to it is read here by its approver (0.70.0).
- `status` (enum, required) — The key's lifecycle status — what an administrator decided; `ACTIVE` is the one that serves. The value set is append-only: treat an unknown name as `UNKNOWN`.
  - Allowed values: `UNKNOWN`, `DRAFT`, `PENDING_APPROVAL`, `ACTIVE`, `DISABLED`, `DELETED`
- `pendingTransition` (string, required) — The key's pending transition by name, `NONE` for none. A key stated at the connection rides the account's `ACTIVATE` (this reads `ACTIVATE` too); since 0.65.0 every later change to a key — added beneath a live account, amended, enabled, deleted or rotated — is the account's `KEY_CHANGE`, this reading the key's own act (`ACTIVATE`, `AMEND`, `ENABLE`, `DELETE`, `ROTATE`); the account's `/approve` and `/withdraw` settle both.
- `health` (CredentialHealthReadings, required) — One venue key is served by every connector role of its venue, and each role reports its own health of the key: the account connector (discovery, balances and the probe) and the order-entry connector (trading). A reading is null until that role has reported on the credential.
- `observed` (AccountKeyObserved, required) — What the key probe observed at the venue.
- `keyIdSuffix` (string, required) — The last four characters of the venue key id — enough to tell keys apart in a venue's console; empty at a venue whose key has no public id (`keyIdLeg` `null`), where `fingerprint` tells them apart.
- `fingerprint` (string, required) — The material's fingerprint, the audit handle behind `venue-keys:read`.
- `createdAtNs` (string, required, nullable) — When the venue issued the key, as stated when it was added; null when not stated.
- `rotateByNs` (string, required, nullable) — The deadline by which the key is to be rotated, epoch nanoseconds as a decimal string; null when none is set. An amend moves it, so a new deadline is read here by its approver (0.70.0).

### AccountAddressUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, optional, nullable) — Platform time of the approval. int64 as a decimal JSON string

### AssetPolicyUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, optional, nullable) — Platform time of the approval. int64 as a decimal JSON string

### ChainPolicyUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, optional, nullable) — Platform time of the approval. int64 as a decimal JSON string

### TradingPolicyUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, optional, nullable) — Platform time of the approval. int64 as a decimal JSON string

### ApprovalRuleUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, optional, nullable) — Platform time of the approval. int64 as a decimal JSON string

### RiskLimitRowApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, required, nullable) — When this approval was given, platform time in epoch nanoseconds as a decimal string.

### TransferRowApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, required, nullable) — When this approval was given, platform time in epoch nanoseconds as a decimal string.
- `isHeadroomAcknowledged` (boolean, required) — Whether this approval overrode the headroom check: it stated `acknowledgeHeadroom` and the check refused the approval without it.

### NotificationEndpointUpdatedAlgoInstancesItem

- `instanceId` (integer, required) — An algo instance.

### NotificationEndpointUpdatedApprovalsItem

- `userId` (integer, required) — An approving user.
- `approvedAtNs` (string, required) — Platform time of the approval. int64 as a decimal JSON string

### AccountCapability

A key holding one of the account's roles: which credential, its lifecycle status, and the latest report from the connector that fills the role.

- `credentialId` (integer, required) — The credential that holds the role.
- `status` (enum, required) — The key's lifecycle status — what an administrator decided; `ACTIVE` is the one that serves. The value set is append-only: treat an unknown name as `UNKNOWN`.
  - Allowed values: `UNKNOWN`, `DRAFT`, `PENDING_APPROVAL`, `ACTIVE`, `DISABLED`, `DELETED`
- `health` (ConnectionHealth, required, nullable) — The role's latest reading, or null when its connector has not reported on the key. Judge it by its `reportedAtNs`, as a credential's `health`.

### CredentialHealthReadings

One venue key is served by every connector role of its venue, and each role reports its own health of the key: the account connector (discovery, balances and the probe) and the order-entry connector (trading). A reading is null until that role has reported on the credential.

- `account` (ConnectionHealth, required, nullable) — The account connector's latest report, or null when no account connector has reported on the credential.
- `trading` (ConnectionHealth, required, nullable) — The order-entry connector's latest report, or null when none has reported on the credential — every key that does not trade.

### AccountKeyObserved

What the key probe observed at the venue.

- `permissions` (list of string, required) — The venue's permissions on the key as the probe read them, in choice order (`read`, `trade`, `withdraw`); empty until a probe answers.
- `allowlist` (string, required) — The probe's verdict on the key's IP allowlist, by name; `UNKNOWN` until a probe answers.
- `outcome` (string, required) — The probe's outcome, a `HealthReason` name: `NONE` for a clean answer, `UNKNOWN` until one, else why it failed (`IP_NOT_WHITELISTED`, `AUTH_FAILED`, `ACCOUNT_EXISTS`, `CONFIG_ERROR`, …).
- `probedAtNs` (string, required, nullable) — When the probe last answered, epoch nanoseconds; null until one has.
- `scopeUnobserved` (boolean, required) — `true` = the probe answered but its venue serves no read of the key's own scope (Binance Demo Mode has no `/sapi`), so `permissions` is empty because nothing stated it and the approval's scope edges are not applied; `false` = the scope, as observed, is the venue's word and is judged.

### ConnectionHealth

- `credentialId` (integer, required) — The credential the report is about.
- `status` (enum, required) — Whether a connector is serving the credential: CONNECTED serves, DEGRADED serves impaired, DOWN does not serve, dialing and redialing included. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `CONNECTED`, `DEGRADED`, `DOWN`
- `reason` (enum, required) — Why the status is what it is; NONE when nothing is wrong. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `NONE`, `AUTH_FAILED`, `IP_NOT_WHITELISTED`, `PERMISSION_DENIED`, `RATE_LIMITED`, `VENUE_UNREACHABLE`, `STARTUP`, `RECONNECT`, `HEARTBEAT_TIMEOUT`, `VENUE_MAINTENANCE`, `BACKPRESSURE`, `RESYNC`, `SHUTDOWN`, `FAILOVER`, `LAGGING`, `RECOVERED`, `INVALID_KEY`, `CLOCK_SKEW`, `CONFIG_ERROR`, `STREAM_STALE`, `VENUE_UNAVAILABLE`, `ACCOUNT_EXISTS`, `ACCOUNT_DISABLED`
- `sinceNs` (string, required) — When the current status and reason began, on the connector's own clock. int64 as a decimal JSON string
- `transitionAtNs` (string, required) — Platform time the current status began. A restatement leaves it, and so does a change of reason alone, so the time since it is how long the credential has been in this status. int64 as a decimal JSON string
- `reportedAtNs` (string, required) — Platform time of the latest report. A connector serving the credential restates its report on a heartbeat, so a time that stops advancing means nothing is reporting on it any more. int64 as a decimal JSON string
- `role` (enum, required) — Which connector role this reading is from: ACCOUNT (balances, the probe) or ORDER_ENTRY (trading). A credential has one reading per role and exchange. UNKNOWN is the unset sentinel: outputs only — as input the field is required, and explicit UNKNOWN refuses 400. A consumer READING this field treats an unknown name as UNKNOWN, never as an error; as input an unknown name refuses 400 — the parse is strict
  - Allowed values: `UNKNOWN`, `ACCOUNT`, `ORDER_ENTRY`
- `detail` (string, required) — What the connector or the venue said, for people: display it, do not parse it. Empty when there is nothing to add. At most 512 bytes (the connector clips what the venue said to that).
- `venueRoundTripNs` (string, optional, nullable) — The latest round trip to the venue the connector measured; 0 = not measured. int64 as a decimal JSON string
- `exchangeId` (integer, optional, nullable) — The exchange this reading is from: the key's own, or a further one its venue trades — a Binance key's spot (100) and USD-M (102) order-entry readings are two. Every reading names its exchange.

## Examples

**Response**

```json
{
  "asOfSeqTsNs": "1791553927418203000",
  "globalSequence": "250113",
  "items": [
    {
      "family": "account-addresses",
      "entityId": 118400607,
      "transferId": null,
      "transition": "ACTIVATE",
      "status": "pending",
      "proposedBy": null,
      "proposedAtNs": "1790931807000000000",
      "requiredApprovals": 1,
      "approvals": [
        {
          "userId": 1,
          "approvedAtNs": null
        }
      ],
      "approvers": [
        {
          "userId": 69761055
        },
        {
          "userId": 76320909
        }
      ],
      "concludedAtNs": null,
      "concludedBy": null,
      "before": null,
      "after": {
        "accountAddressId": 118400607,
        "accountId": 118310760,
        "address": "0xc41e07b2a9d35f8e6b0a1c7d29e4f5038ab6d1c2",
        "approvals": [
          {
            "userId": 1
          }
        ],
        "assetId": 101,
        "chain": "ETHEREUM",
        "concludedTransition": "NONE",
        "lastWithdrawalReason": "",
        "memo": "",
        "orgId": 69761052,
        "pendingTransition": "ACTIVATE",
        "proposedAtNs": "1790931807000000000",
        "remark": "",
        "source": "OBSERVED",
        "status": "UNVERIFIED",
        "version": "1"
      },
      "remark": "",
      "returnedByActor": null,
      "returnedAtNs": null,
      "reason": "",
      "returnedBy": null
    },
    {
      "family": "accounts",
      "entityId": 118400441,
      "transferId": null,
      "transition": "ACTIVATE",
      "status": "pending",
      "proposedBy": {
        "kind": "USER",
        "id": 69761055
      },
      "proposedAtNs": "1790931641000000000",
      "requiredApprovals": 2,
      "approvals": [
        {
          "userId": 1,
          "approvedAtNs": null
        }
      ],
      "approvers": [
        {
          "userId": 76320909
        }
      ],
      "concludedAtNs": null,
      "concludedBy": null,
      "before": null,
      "after": {
        "accountId": 118400441,
        "approvals": [
          {
            "userId": 1
          }
        ],
        "capabilities": {
          "trade": {
            "credentialId": 85407636,
            "health": null,
            "status": "PENDING_APPROVAL"
          },
          "transfer": null
        },
        "concludedTransition": "NONE",
        "connection": {
          "readAtNs": null,
          "reason": "NONE",
          "status": "CONNECTED"
        },
        "displayName": "okx-mm",
        "exchangeId": 300,
        "keys": [
          {
            "canReadBalances": true,
            "canServeAddresses": false,
            "createdAtNs": "1757938836000000000",
            "fingerprint": "fp-fba0318d89e6c235",
            "health": {
              "account": null,
              "trading": null
            },
            "keyId": 85407636,
            "keyIdSuffix": "2f6e",
            "name": "okx-hedge",
            "observed": {
              "allowlist": "COVERS",
              "outcome": "NONE",
              "permissions": [
                "read",
                "trade"
              ],
              "probedAtNs": "1791553500000000000",
              "scopeUnobserved": false
            },
            "pendingTransition": "ACTIVATE",
            "rotateByNs": "1789474836000000000",
            "status": "PENDING_APPROVAL",
            "trade": true,
            "transfer": false,
            "version": "1"
          }
        ],
        "lastWithdrawalReason": "",
        "orgId": 69761052,
        "ownership": "HOUSE",
        "parentAccountId": 118310760,
        "parentExternalRef": "482910375",
        "pendingTransition": "ACTIVATE",
        "portfolioId": 85406744,
        "proposedAtNs": "1790931641000000000",
        "proposedBy": {
          "id": 69761055,
          "kind": "USER"
        },
        "purpose": "HEDGE",
        "readAtNs": null,
        "remark": "Market-making sub-account for the Q4 programme",
        "status": "PENDING_APPROVAL",
        "trading": null,
        "venueAccountRef": "482910412",
        "version": "1"
      },
      "remark": "Market-making sub-account for the Q4 programme",
      "returnedByActor": null,
      "returnedAtNs": null,
      "reason": "",
      "returnedBy": null
    }
  ],
  "nextCursor": "AQBNQgGovVUB7gAdYWNjb3VudHMAMDAwMDAwMDAwMDExODQwMDQ0MQE",
  "total": 7
}
```

**SDK Code**

```python
import requests

url = "https://api.example.com/approvals"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.example.com/approvals';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/approvals"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.example.com/approvals")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.example.com/approvals")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.example.com/approvals', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/approvals");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/approvals")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```