> 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://docs.api.corpx.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.api.corpx.com/_mcp/server.

# Get transaction timeline

GET https://client.api.corpx.com/v1/accounts/{accountId}/transactions/timeline

Returns the timeline of events for a single transaction (by PIX end-to-end ID or integrator identifier).
Includes creation, BACEN confirmations (inbound webhooks as short descriptions), outbound webhooks sent to the client (with optional full payload for "Ver payload completo"), fees, refunds, and QR code lifecycle when applicable.
Exactly one of `endToEndId` or `identifier` is required.


Reference: https://docs.api.corpx.com/ib/referencia/accounts/get-transaction-timeline

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

- `endToEndId` (string, optional) — PIX end-to-end ID. Mutually exclusive with identifier.
- `identifier` (string, optional) — Integrator reference (payment/QR identifier). Mutually exclusive with endToEndId.

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

Transaction timeline.

- `transaction` (TransactionTimelineSummary, required) — Short summary of the transaction for the timeline response.
- `timeline` (list of TimelineEvent, required)

## Errors

### 400 Bad Request Error

Missing or invalid params (e.g. both endToEndId and identifier set).

- `any`

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

### TransactionTimelineSummary

Short summary of the transaction for the timeline response.

- `transactionId` (string, optional)
- `endToEndId` (string, optional)
- `identifier` (string, optional)
- `transactionType` (string, optional)
- `status` (string, optional)
- `amount` (double, optional)
- `currency` (string, optional)
- `direction` (enum, optional)
  - Allowed values: `IN`, `OUT`
- `createdAt` (datetime, optional)

### TimelineEvent

A single event in the transaction timeline.

- `eventType` (string, optional) — Event kind (e.g. webhook_received, webhook_sent, fee_charged, qrcode_created).
- `occurredAt` (datetime, optional)
- `description` (string, optional) — Human-readable summary (e.g. BACEN confirmation text; no raw payload for inbound). For outbound, summary plus optional payloadSent for Ver payload completo.
- `payloadSent` (map from string to any, optional) — Only present for webhook_sent events; full JSON sent to the client.

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

## Examples

**Response**

```json
{
  "transaction": {
    "transactionId": "8c1f6a2e-4d3b-4b9a-9f0e-1a2b3c4d5e6f",
    "endToEndId": "E22896431202602200833NdtppklLCj2",
    "identifier": "order-12345",
    "transactionType": "PIX",
    "status": "COMPLETED",
    "amount": 150.75,
    "currency": "BRL",
    "direction": "IN",
    "createdAt": "2026-02-20T08:33:39Z"
  },
  "timeline": [
    {
      "eventType": "pix.in.completed",
      "occurredAt": "2026-02-20T08:33:39Z",
      "description": "Pagamento pedido #12345",
      "payloadSent": {}
    }
  ]
}
```

**SDK Code**

```python Accounts_getTransactionTimeline_example
import requests

url = "https://client.api.corpx.com/v1/accounts/accountId/transactions/timeline"

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)

print(response.json())
```

```javascript Accounts_getTransactionTimeline_example
const url = 'https://client.api.corpx.com/v1/accounts/accountId/transactions/timeline';
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_getTransactionTimeline_example
package main

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

func main() {

	url := "https://client.api.corpx.com/v1/accounts/accountId/transactions/timeline"

	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_getTransactionTimeline_example
require 'uri'
require 'net/http'

url = URI("https://client.api.corpx.com/v1/accounts/accountId/transactions/timeline")

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_getTransactionTimeline_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/transactions/timeline")
  .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_getTransactionTimeline_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://client.api.corpx.com/v1/accounts/accountId/transactions/timeline', [
  '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_getTransactionTimeline_example
using RestSharp;

var client = new RestClient("https://client.api.corpx.com/v1/accounts/accountId/transactions/timeline");
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_getTransactionTimeline_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/transactions/timeline")! 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()
```