> This page is for Internet banking (beta).

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

# Search the statement by fields the provider cannot filter

GET https://client.api.corpx.com/v1/accounts/{accountId}/statement/advanced

Filters the statement by **PIX key, counterparty, amount range, direction
and status** — fields the banking provider does not filter server-side.

### Read this before integrating

This endpoint is **expensive by construction**. Because the provider
cannot filter by these fields, every call walks the statement for the
period page by page and applies the filters row by row. A single call may
cost dozens of upstream requests and take **considerably longer** than the
regular statement.

It exists to make one-off investigation and manual reconciliation easy.
**Do not abuse it, and never use it for recurring queries or polling.**
For continuous tracking of incoming PIX, use
[webhooks](/docs/webhooks); for bulk data, use the regular paginated
statement or the CSV export.

Prefer `GET /v1/accounts/{accountId}/statement` whenever its native
filters are enough (period, operation type, order). Reach for this
endpoint only when you need a field that only it can filter.

### Pagination is by cursor, not page number

There is no page number: an item's position in the filtered result has no
fixed relationship to its position in the raw statement, so jumping to an
arbitrary page would mean re-walking the period from the start.

Each call spends a bounded budget (a maximum number of provider pages and
a wall-clock limit). When the budget runs out before the end of the
period, the response carries `exhausted: false` and a `nextCursor` —
repeat the call passing `cursor=<nextCursor>` to resume exactly where the
scan stopped. When `exhausted` is `true`, the period was fully walked and
what you received is everything that matches.

### Default order is oldest first; `order=desc` is for "just the end of the day"

By default the scan runs in ascending date order and the response echoes
`order: "asc"`. This is what makes cursor resumption exact rather than a
preference: the cursor is a position in the provider's statement, so in
descending order an entry arriving mid-scan would enter at the top and
push every later position along — the resumed call would return rows you
already received. In ascending order new entries land at the end and
nothing already scanned moves. Since the default window is the current
day, it almost always includes "now", so this is the common case.

`order=desc` exists for accounts with thousands of entries a day that only
want the **most recent** ones: the scan starts from the newest and stops
as soon as the result page is full. In this mode **`cursor` is refused**
(`400 invalid_cursor`) for the reason above. To continue, use time
instead of position: when `exhausted` is `false` the response carries
`nextOccurredBefore`; pass it as `occurredBefore` on the next call. It is
the instant of the last row examined, and the window is inclusive, so
rows sharing that same second may come back — deduplicate by `id`. A
time boundary does not move when a new entry lands at the top, which is
what makes it safe where a cursor is not. Each continuation re-reads from
the newest down to the boundary (the provider paginates by position), so
`desc` is for the tail of the period; to walk a whole period backwards,
use `asc` with a cursor.

### `occurredAfter` / `occurredBefore` narrow by time of day

Both are RFC 3339 instants **with an explicit offset** (`-03:00` or `Z`),
inclusive on both ends, applied on top of the date window. They only
shorten the scan when they are the boundary in the scan direction:
`occurredAfter` with `order=desc` and `occurredBefore` with `order=asc`
stop the scan the moment the boundary is crossed (`exhausted: true`). In
the opposite direction they are just filters — the provider only accepts
dates, so the pages before the instant are still read. Typical use:
`order=desc&occurredAfter=2026-09-20T17:00:00-03:00` to get everything
since 17:00 without walking the morning.

A call may legitimately return **zero items with a cursor** (or with
`nextOccurredBefore`): it means the budget was spent on rows that did not
match, not that there is nothing to find.

The cursor is bound to the filter set. Changing any filter invalidates it
and the API answers `400 invalid_cursor` — start the search over without a
cursor.

There is no total count, on purpose: counting would require walking the
whole period, which is the very cost this design avoids.

Reference: https://en.docs.api.corpx.com/ib/referencia/accounts/get-account-statement-advanced

## Authentication

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

## Request

### Path parameters

- `accountId` (string, required) — Account identifier.

### Query parameters

- `startDate` (date, optional) — Inclusive start date (YYYY-MM-DD). Default: today.
- `endDate` (date, optional) — Inclusive end date (YYYY-MM-DD). Maximum window is 31 days.
- `cursor` (string, optional) — Opaque resume token from a previous `nextCursor`. Only valid for the same filter set and only with `order=asc`; with `order=desc` it is refused (`400 invalid_cursor`) — continue with `occurredBefore` instead.
- `order` (enum, optional, default: asc) — Scan direction. `asc` (default) walks oldest → newest and supports `cursor`. `desc` walks newest → oldest, for "only the most recent" queries on busy accounts; no cursor, continue with `occurredBefore=<nextOccurredBefore>`.
  - Allowed values: `asc`, `desc`
- `occurredAfter` (datetime, optional) — Inclusive lower bound on the row instant (RFC 3339 **with offset**). With `order=desc` it stops the scan once crossed, which is what makes "everything since 17:00" cheap; with `order=asc` it is only a filter.
- `occurredBefore` (datetime, optional) — Inclusive upper bound on the row instant (RFC 3339 **with offset**). With `order=asc` it stops the scan once crossed; with `order=desc` it is the continuation boundary (pass the previous `nextOccurredBefore`).
- `size` (integer, optional, default: 50) — Maximum number of **matching** items per call (max 100).
- `direction` (enum, optional) — Credits (IN) or debits (OUT).
  - Allowed values: `IN`, `OUT`
- `operation` (enum, optional) — Operation type. Pushed down to the provider when possible, narrowing the scan.
  - Allowed values: `PIX`, `TED`, `INTERNAL_TRANSFER`, `BOLETO`, `FEE`
- `status` (string, optional) — Canonical status (COMPLETED, PROCESSING, FAILED, REFUNDED, REVERSED).
- `pixKey` (string, optional) — Exact PIX key used in the transaction, case-insensitive. On a credit this is the key of **this** account that received; on a debit, the destination key. Rows without a key (payer used branch/account, or non-PIX operations) never match this filter.
- `counterpartyName` (string, optional) — Partial counterparty name. Accent- and case-insensitive, and order-independent: every whitespace-separated term must appear somewhere in the name, in any order.
- `counterpartyDocument` (string, optional) — Counterparty CPF/CNPJ. Punctuation is ignored.
- `minAmount` (double, optional) — Minimum absolute amount, inclusive.
- `maxAmount` (double, optional) — Maximum absolute amount, inclusive.

### Headers

- `X-Tenant-Id` (string, required) — Tenant context used for authorization and routing.
- `X-Request-Timestamp` (string, required) — Unix seconds. Required on the signed host; tolerance is 300s either way (`403 request_timestamp_skew`).
- `X-Content-SHA256` (string, required) — Lowercase hex SHA-256 of the body. An empty body hashes the empty string, so the header is always present. Mismatch returns `400 body_hash_mismatch`.
- `X-Request-Signature` (string, required) — Detached JWS (`<protected>..<signature>`, ES256 or PS256) over `METHOD\nPATH?QUERY\nTIMESTAMP\nIDEMPOTENCY_KEY_OR_EMPTY\nX_CONTENT_SHA256`.

## Response

### 200

Matching statement rows for the scanned portion of the period, in the requested `order` (oldest first by default).

- `accountId` (string, required)
- `items` (list of AccountStatementEntry, required)
- `exhausted` (boolean, required) — `true` = o recorte foi varrido até o fim (ou a fronteira de horário foi cruzada) e estes são TODOS os lançamentos que casam com o filtro. `false` = ainda há o que varrer; continue com `nextCursor` (`asc`) ou `occurredBefore=nextOccurredBefore` (`desc`).
- `tenantId` (string, optional)
- `source` (string, optional)
- `startDate` (date, optional)
- `endDate` (date, optional)
- `size` (integer, optional) — Quantidade de itens nesta resposta.
- `order` (enum, optional) — Direção da varredura, ecoada do pedido. `asc` (padrão) é a única com cursor: a varredura tem de ser crescente para o cursor retomar na posição certa — em ordem decrescente, um lançamento que chega durante a varredura desloca as posições já lidas. `desc` continua por tempo (`nextOccurredBefore`).
  - Allowed values: `asc`, `desc`
- `nextCursor` (string, optional) — Token opaco de retomada. Presente apenas quando `exhausted` é `false` e `order` é `asc`. Só vale para a mesma combinação de filtros.
- `nextOccurredBefore` (datetime, optional) — Fronteira de continuação em `order=desc`, presente quando `exhausted` é `false`: instante do último lançamento examinado. Repita a chamada com `occurredBefore` igual a este valor. Como o limite é inclusivo, lançamentos no mesmo segundo podem voltar — dedupe pelo `id`. Ausente se o último lançamento examinado não tinha instante conhecido.
- `partialReason` (enum, optional) — Por que a varredura parou antes do fim do período. `page_full` = a resposta encheu; `scan_budget` / `time_budget` = o orçamento de páginas ou de tempo da chamada acabou; `partner_error` = o liquidante recusou uma chamada no meio da varredura e devolvemos o que já havia sido coletado.
  - Allowed values: `page_full`, `scan_budget`, `time_budget`, `partner_error`
- `scan` (AdvancedStatementScan, optional) — Custo desta chamada, para o cliente dimensionar o uso.
- `fetchedAt` (datetime, optional)

## Errors

### 400 Bad Request Error

Invalid filter or cursor: `invalid_date_range`, `date_range_too_wide` (window over 31 days), `invalid_filter` (unknown enum value, malformed amount, `order` outside asc/desc, instant without offset, or `occurredAfter` later than `occurredBefore`) or `invalid_cursor` (malformed, belonging to a different filter set, or sent with `order=desc`).

- `errorCode` (string, required) — Stable machine-readable code. See `ErrorCode` for the known values.
- `message` (string, required) — Human-readable explanation (pt-BR). Presentation only; may change.
- `docs` (string, optional) — Link to this code in the public error catalogue.
- `requestId` (string, optional) — Gateway request id. Quote it when contacting support.
- `details` (map from string to any, optional) — Optional machine-readable context for the specific `errorCode` (for example `kind` on `identity_verification_monthly_limit_exceeded`, `maxBytes` on `payload_too_large`, `attemptsRemaining` on `facetec_attempts_exhausted`). Keys are documented per operation; absent when the code carries no extra context.
- `partner` (ErrorResponsePartner, optional) — Raw error from the settlement bank, when the failure came from it. Diagnostic only.

### 404 Not Found Error

Requested resource was not found.

- `errorCode` (string, required) — Stable machine-readable code. See `ErrorCode` for the known values.
- `message` (string, required) — Human-readable explanation (pt-BR). Presentation only; may change.
- `docs` (string, optional) — Link to this code in the public error catalogue.
- `requestId` (string, optional) — Gateway request id. Quote it when contacting support.
- `details` (map from string to any, optional) — Optional machine-readable context for the specific `errorCode` (for example `kind` on `identity_verification_monthly_limit_exceeded`, `maxBytes` on `payload_too_large`, `attemptsRemaining` on `facetec_attempts_exhausted`). Keys are documented per operation; absent when the code carries no extra context.
- `partner` (ErrorResponsePartner, optional) — Raw error from the settlement bank, when the failure came from it. Diagnostic only.

### 500 Internal Server Error

Unexpected server error.

- `errorCode` (string, required) — Stable machine-readable code. See `ErrorCode` for the known values.
- `message` (string, required) — Human-readable explanation (pt-BR). Presentation only; may change.
- `docs` (string, optional) — Link to this code in the public error catalogue.
- `requestId` (string, optional) — Gateway request id. Quote it when contacting support.
- `details` (map from string to any, optional) — Optional machine-readable context for the specific `errorCode` (for example `kind` on `identity_verification_monthly_limit_exceeded`, `maxBytes` on `payload_too_large`, `attemptsRemaining` on `facetec_attempts_exhausted`). Keys are documented per operation; absent when the code carries no extra context.
- `partner` (ErrorResponsePartner, optional) — Raw error from the settlement bank, when the failure came from it. Diagnostic only.

## Types

### AccountStatementEntry

Linha do extrato. `payer` e `payee` são montados a partir de `direction`: * `direction=IN`: `payer` = contraparte (quem nos pagou); `payee` = a nossa conta (titular consultado). * `direction=OUT`: `payer` = a nossa conta; `payee` = contraparte (a quem pagamos). O lado **self** sempre traz `name` (titular) + `document` (CPF/CNPJ) + identificadores do banco liquidante (`bankCode`, `bankIspb`, `bankName`). O lado **contraparte** traz apenas `name` + `document`. Campos opcionais (`branch`, `account`, `pixKey`, `accountType`, `bankCode`, `bankIspb`, `bankName`) ficam omitidos quando vazios — o extrato do liquidante não os expõe. Para o payload completo da contraparte, use `GET /v1/accounts/{id}/pix/payments/lookup?endToEndId=...` ou o webhook outbound (`pix.in.completed`, `pix.out.completed`, etc.).

- `operation` (string, required) — Canonical type: PIX, TED, BOLETO, FEE, INTERNAL_TRANSFER.
- `amount` (double, required) — Signed amount in BRL (negative = debit, positive = credit).
- `currency` (string, required)
- `timestamp` (datetime, required) — Transaction timestamp in RFC3339 with São Paulo offset (-03:00).
- `partnerId` (string, optional) — Settlement bank operation reference.
- `endToEndId` (string, optional)
- `direction` (enum, optional)
  - Allowed values: `IN`, `OUT`
- `partnerType` (string, optional) — Partner operation label. `PIX_REFUND` on a PIX refund line (`reversal: true`); `operation` stays `PIX`. `P2P_CRYPTO_ORDER` on the legs of a P2P order (identifier `p2p-…` or `fee-p2p-…`).
- `status` (string, optional) — Canonical transaction status. Possible values: `COMPLETED`, `PROCESSING`, `FAILED`, `PENDING`, `PENDING_APPROVAL`, `REVERSED`, `UNKNOWN`. `PENDING_APPROVAL` means the partner accepted the request but is holding it for internal approval (multi-step authorisation, 2FA, anti-fraud). No BACEN end-to-end ID exists yet — funds have not moved.
- `description` (string, optional)
- `title` (string, optional) — Human-readable operation label from partner.
- `recipientName` (string, optional) — Atalho — nome da contraparte (igual a `counterParty.name`).
- `recipientDocument` (string, optional) — Atalho — documento da contraparte (igual a `counterParty.document`).
- `pixKey` (string, optional) — Chave PIX usada na transação. Num **crédito** é a chave desta conta que recebeu; num **débito**, a chave de destino. Distinta de `counterParty.pixKey`, que descreve a contraparte — num crédito o liquidante costuma preencher esta e deixar a da contraparte vazia. Omitida fora de PIX e em lançamentos anteriores à versão do liquidante que passou a informá-la. Para filtrar o extrato por chave, use `GET /v1/accounts/{accountId}/statement/advanced`.
- `counterParty` (AccountStatementEntryCounterParty, optional) — Contraparte da transação (nome + documento e, quando o liquidante informa, dados bancários: banco, agência, conta, ISPB e chave PIX). Os campos bancários são omitidos quando vazios.
- `transactionType` (enum, optional) — Partner credit/debit code: `C` = credit (IN), `D` = debit (OUT). Mirrors `direction`.
  - Allowed values: `C`, `D`
- `identifier` (string, optional)
- `reversal` (boolean, optional) — True when this line is a PIX refund (the settlement bank linked it to the original PIX via `originalEndToEnd`).
- `originalEndToEnd` (string, optional) — End-to-end of the PIX this line refunds. Empty on an ordinary movement. On a refund we initiated, this can equal `endToEndId`.
- `refundEndToEnd` (string, optional) — End-to-end of the refund that reversed this line, when the settlement bank reports one. Present on the original PIX after a refund, including a partial refund. Empty on the refund line itself.
- `feeServiceType` (string, optional) — Service behind a fee line: `PIX`, `TED`, `BOLETO`, `INTERNAL_TRANSFER`, `MONTHLY`, `P2P_CRYPTO` or `OTHER`.
- `p2pOrderId` (string, optional) — P2P order of this line, from the reserved identifier. On these lines the counterparty is only `ORDEM P2P CRIPTO` (no document) and `description` is `COMPRA P2P CRIPTO`, `VENDA P2P CRIPTO`, `TAXA INTERMEDIAÇÃO KYC P2P CRIPTO` or `ESTORNO TAXA INTERMEDIAÇÃO KYC P2P CRIPTO`.
- `p2pKind` (enum, optional) — Leg of the P2P order.
  - Allowed values: `payment`, `fee`, `fee_refund`
- `p2pOrder` (AccountStatementEntryP2POrder, optional) — Summary of your own order. Absent when the account is not a party or the order could not be read.
- `balance` (double, optional)
- `source` (enum, optional) — Data source for this line (`live` = settlement bank, real time).
  - Allowed values: `live`
- `ispb` (string, optional) — 8-digit ISPB of the bank that processed the transaction (settlement bank: 50871921).
- `payer` (TransactionParty, optional) — Transaction counterparty (payer or beneficiary).
- `payee` (TransactionParty, optional) — Transaction counterparty (payer or beneficiary).
- `initiation` (string, optional) — PIX initiation type (present on exact lookups by endToEndId/identifier): e.g. pix-key, manual, static-qrcode, dynamic-qrcode.
- `errorMessage` (string, optional) — Partner error message, when the transaction is in a failed/reversed state (present on exact lookups).
- `boletoBarcode` (string, optional) — Código do boleto como o liquidante informou na linha do extrato, só dígitos. Normalmente o código de barras (44 dígitos); o liquidante pode devolver a linha digitável no mesmo campo (47, ou 48 em arrecadação) — identifique pelo tamanho. Presente apenas quando `operation=BOLETO` — pagamento (`BOLETO_PAYMENT`) e cobrança liquidada (`BOLETO_SETTLEMENT`). Omitido fora de boleto e quando vazio.

### AdvancedStatementScan

Custo desta chamada, para o cliente dimensionar o uso.

- `pagesRead` (integer, optional) — Páginas do extrato do liquidante lidas nesta chamada.
- `itemsScanned` (integer, optional) — Linhas examinadas nesta chamada (casando ou não).
- `maxPages` (integer, optional) — Teto de páginas por chamada.

### ErrorResponsePartner

Raw error from the settlement bank, when the failure came from it. Diagnostic only.

- `code` (string, optional)
- `message` (string, optional)
- `field` (string, optional) — Field the partner pointed at, when any.

### AccountStatementEntryCounterParty

Contraparte da transação (nome + documento e, quando o liquidante informa, dados bancários: banco, agência, conta, ISPB e chave PIX). Os campos bancários são omitidos quando vazios.

- `name` (string, optional)
- `document` (string, optional)
- `bankName` (string, optional)
- `bankIspb` (string, optional)
- `bankCode` (string, optional)
- `branch` (string, optional)
- `account` (string, optional)
- `accountType` (string, optional)
- `pixKey` (string, optional)

### AccountStatementEntryP2POrder

Summary of your own order. Absent when the account is not a party or the order could not be read.

- `orderId` (string, optional)
- `kind` (enum, optional)
  - Allowed values: `payment`, `fee`, `fee_refund`
- `role` (enum, optional)
  - Allowed values: `buyer`, `seller`
- `side` (enum, optional)
  - Allowed values: `buy`, `sell`
- `pair` (string, optional)
- `cryptoAmount` (string, optional)

### TransactionParty

Transaction counterparty (payer or beneficiary).

- `name` (string, optional) — Full name.
- `document` (string, optional) — CPF/CNPJ as reported by the settlement bank.
- `bankIspb` (string, optional) — Bank ISPB.
- `bankCode` (string, optional) — Bank code (COMPE).
- `bankName` (string, optional) — Bank name.
- `branch` (string, optional) — Branch.
- `account` (string, optional) — Account number.
- `accountType` (string, optional) — Account type, when the settlement bank reports it.
- `pixKey` (string, optional) — PIX key associated with the party.

## Examples

**Response**

```json
{
  "accountId": "2e6b725b-84a0-400d-8740-22a5ba0f23e6",
  "items": [
    {
      "operation": "PIX",
      "amount": 150.75,
      "currency": "BRL",
      "timestamp": "2026-02-20T08:33:39Z",
      "partnerId": "8c1f6a2e-4d3b-4b9a-9f0e-1a2b3c4d5e6f",
      "endToEndId": "E22896431202602200833NdtppklLCj2",
      "direction": "IN",
      "partnerType": "PIX",
      "status": "COMPLETED",
      "description": "Pagamento pedido #12345",
      "title": "Conta corrente",
      "recipientName": "MARIA DA SILVA",
      "recipientDocument": "12345678900",
      "pixKey": "db5c2a29-243e-42a2-862b-89737c0213aa",
      "counterParty": {
        "name": "MARIA DA SILVA",
        "document": "12345678900",
        "bankName": "MARIA DA SILVA",
        "bankIspb": "36741675",
        "bankCode": "36741675",
        "branch": "0001",
        "account": "200037834",
        "accountType": "PIX",
        "pixKey": "db5c2a29-243e-42a2-862b-89737c0213aa"
      },
      "transactionType": "C",
      "identifier": "order-12345",
      "reversal": true,
      "originalEndToEnd": "E22896431202602200833NdtppklLCj2",
      "feeServiceType": "PIX",
      "balance": 150.75,
      "source": "live",
      "ispb": "50871921",
      "payer": {
        "name": "MARIA DA SILVA",
        "document": "123***01",
        "bankCode": "001",
        "bankName": "BANCO DO BRASIL",
        "branch": "0001",
        "account": "12345678",
        "pixKey": "db5c2a29-243e-42a2-862b-89737c0213aa"
      },
      "payee": {
        "name": "MARIA DA SILVA",
        "document": "123***01",
        "bankCode": "001",
        "bankName": "BANCO DO BRASIL",
        "branch": "0001",
        "account": "12345678",
        "pixKey": "db5c2a29-243e-42a2-862b-89737c0213aa"
      },
      "initiation": "MANUAL"
    }
  ],
  "exhausted": true,
  "tenantId": "tn_7f3a9c",
  "source": "live",
  "startDate": "2026-02-20",
  "endDate": "2026-02-20",
  "size": 50,
  "order": "asc",
  "nextCursor": "eyJvZmZzZXQiOjUwfQ",
  "partialReason": "page_full",
  "scan": {
    "pagesRead": 1,
    "itemsScanned": 1,
    "maxPages": 1
  },
  "fetchedAt": "2026-02-20T08:33:39Z"
}
```

**SDK Code**

```python Accounts_getAccountStatementAdvanced_example
import requests

url = "https://client.api.corpx.com/v1/accounts/accountId/statement/advanced"

querystring = {"occurredAfter":"2026-09-20T17:00:00-03:00","occurredBefore":"2026-09-20T18:00:00-03:00"}

headers = {
    "X-Content-SHA256": "X-Content-SHA256",
    "X-Request-Signature": "X-Request-Signature",
    "X-Request-Timestamp": "X-Request-Timestamp",
    "X-Tenant-Id": "X-Tenant-Id",
    "Authorization": "Bearer <token>"
}

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

print(response.json())
```

```javascript Accounts_getAccountStatementAdvanced_example
const url = 'https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00';
const options = {
  method: 'GET',
  headers: {
    'X-Content-SHA256': 'X-Content-SHA256',
    'X-Request-Signature': 'X-Request-Signature',
    'X-Request-Timestamp': 'X-Request-Timestamp',
    'X-Tenant-Id': 'X-Tenant-Id',
    Authorization: 'Bearer <token>'
  }
};

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

```go Accounts_getAccountStatementAdvanced_example
package main

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

func main() {

	url := "https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00"

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

	req.Header.Add("X-Content-SHA256", "X-Content-SHA256")
	req.Header.Add("X-Request-Signature", "X-Request-Signature")
	req.Header.Add("X-Request-Timestamp", "X-Request-Timestamp")
	req.Header.Add("X-Tenant-Id", "X-Tenant-Id")
	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 Accounts_getAccountStatementAdvanced_example
require 'uri'
require 'net/http'

url = URI("https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00")

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

request = Net::HTTP::Get.new(url)
request["X-Content-SHA256"] = 'X-Content-SHA256'
request["X-Request-Signature"] = 'X-Request-Signature'
request["X-Request-Timestamp"] = 'X-Request-Timestamp'
request["X-Tenant-Id"] = 'X-Tenant-Id'
request["Authorization"] = 'Bearer <token>'

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

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

HttpResponse<String> response = Unirest.get("https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00")
  .header("X-Content-SHA256", "X-Content-SHA256")
  .header("X-Request-Signature", "X-Request-Signature")
  .header("X-Request-Timestamp", "X-Request-Timestamp")
  .header("X-Tenant-Id", "X-Tenant-Id")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'X-Content-SHA256' => 'X-Content-SHA256',
    'X-Request-Signature' => 'X-Request-Signature',
    'X-Request-Timestamp' => 'X-Request-Timestamp',
    'X-Tenant-Id' => 'X-Tenant-Id',
  ],
]);

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

```csharp Accounts_getAccountStatementAdvanced_example
using RestSharp;

var client = new RestClient("https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Content-SHA256", "X-Content-SHA256");
request.AddHeader("X-Request-Signature", "X-Request-Signature");
request.AddHeader("X-Request-Timestamp", "X-Request-Timestamp");
request.AddHeader("X-Tenant-Id", "X-Tenant-Id");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Accounts_getAccountStatementAdvanced_example
import Foundation

let headers = [
  "X-Content-SHA256": "X-Content-SHA256",
  "X-Request-Signature": "X-Request-Signature",
  "X-Request-Timestamp": "X-Request-Timestamp",
  "X-Tenant-Id": "X-Tenant-Id",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://client.api.corpx.com/v1/accounts/accountId/statement/advanced?occurredAfter=2026-09-20T17%3A00%3A00-03%3A00&occurredBefore=2026-09-20T18%3A00%3A00-03%3A00")! 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()
```