Listing payments API docs

To view your payment history, you can list all the payments that have been sent and received.

Rust

let response = sdk
    .list_payments(ListPaymentsRequest::default())
    .await?;
let payments = response.payments;

Swift

let response = try await sdk.listPayments(
    request: ListPaymentsRequest())
let payments = response.payments

Kotlin

try {
    val response = sdk.listPayments(ListPaymentsRequest())
    val payments = response.payments
} catch (e: Exception) {
    // handle error
}

Javascript

const response = await sdk.listPayments({})
const payments = response.payments

React Native

const response = await sdk.listPayments({
  typeFilter: undefined,
  statusFilter: undefined,
  assetFilter: undefined,
  fromTimestamp: undefined,
  toTimestamp: undefined,
  offset: undefined,
  limit: undefined,
  sortAscending: undefined
})
const payments = response.payments

Flutter

ListPaymentsRequest request = ListPaymentsRequest();
ListPaymentsResponse response = await sdk.listPayments(request: request);
List<Payment> payments = response.payments;

Python

response = await sdk.list_payments(request=ListPaymentsRequest())
payments = response.payments

response, err := sdk.ListPayments(breez_sdk_spark.ListPaymentsRequest{})

if sdkErr := err.(*breez_sdk_spark.SdkError); sdkErr != nil {
    return nil, err
}

payments := response.Payments

Filtering Payments

When listing payments you can also filter and page the results.

Rust

// Filter by asset (Bitcoin or Token)
let asset_filter = AssetFilter::Token {
    token_identifier: Some("token_identifier_here".to_string()),
};
// To filter by Bitcoin instead:
// let asset_filter = AssetFilter::Bitcoin;

let response = sdk
    .list_payments(ListPaymentsRequest {
        // Filter by payment type
        type_filter: Some(vec![PaymentType::Send, PaymentType::Receive]),
        // Filter by status
        status_filter: Some(vec![PaymentStatus::Completed]),
        asset_filter: Some(asset_filter),
        // Time range filters
        from_timestamp: Some(1704067200), // Unix timestamp
        to_timestamp: Some(1735689600),   // Unix timestamp
        // Pagination
        offset: Some(0),
        limit: Some(50),
        // Sort order (true = oldest first, false = newest first)
        sort_ascending: Some(false),
    })
    .await?;
let payments = response.payments;

Swift

// Filter by asset (Bitcoin or Token)
let assetFilter = AssetFilter.token(tokenIdentifier: "token_identifier_here")
// To filter by Bitcoin instead:
// let assetFilter = AssetFilter.bitcoin

let response = try await sdk.listPayments(
    request: ListPaymentsRequest(
        // Filter by payment type
        typeFilter: [PaymentType.send, PaymentType.receive],
        // Filter by status
        statusFilter: [PaymentStatus.completed],
        assetFilter: assetFilter,
        // Time range filters
        fromTimestamp: 1_704_067_200,  // Unix timestamp
        toTimestamp: 1_735_689_600,  // Unix timestamp
        // Pagination
        offset: 0,
        limit: 50,
        // Sort order (true = oldest first, false = newest first)
        sortAscending: false
    ))
let payments = response.payments

Kotlin

try {
    // Filter by asset (Bitcoin or Token)
    val assetFilter = AssetFilter.Token(tokenIdentifier = "token_identifier_here")
    // To filter by Bitcoin instead:
    // val assetFilter = AssetFilter.Bitcoin

    val response = sdk.listPayments(
        ListPaymentsRequest(
            // Filter by payment type
            typeFilter = listOf(PaymentType.SEND, PaymentType.RECEIVE),
            // Filter by status
            statusFilter = listOf(PaymentStatus.COMPLETED),
            assetFilter = assetFilter,
            // Time range filters
            fromTimestamp = 1704067200u, // Unix timestamp
            toTimestamp = 1735689600u,   // Unix timestamp
            // Pagination
            offset = 0u,
            limit = 50u,
            // Sort order (true = oldest first, false = newest first)
            sortAscending = false
        ))
    val payments = response.payments
} catch (e: Exception) {
    // handle error
}

Javascript

// Filter by asset (Bitcoin or Token)
const assetFilter: AssetFilter = { type: 'token', tokenIdentifier: 'token_identifier_here' }
// To filter by Bitcoin instead:
// const assetFilter: AssetFilter = { type: 'bitcoin' }

const response = await sdk.listPayments({
  // Filter by payment type
  typeFilter: ['send', 'receive'],
  // Filter by status
  statusFilter: ['completed'],
  assetFilter,
  // Time range filters
  fromTimestamp: 1704067200, // Unix timestamp
  toTimestamp: 1735689600, // Unix timestamp
  // Pagination
  offset: 0,
  limit: 50,
  // Sort order (true = oldest first, false = newest first)
  sortAscending: false
})
const payments = response.payments

React Native

// Filter by asset (Bitcoin or Token)
const assetFilter = new AssetFilter.Token({ tokenIdentifier: 'token_identifier_here' })
// To filter by Bitcoin instead:
// const assetFilter = new AssetFilter.Bitcoin()

const response = await sdk.listPayments({
  // Filter by payment type
  typeFilter: [PaymentType.Send, PaymentType.Receive],
  // Filter by status
  statusFilter: [PaymentStatus.Completed],
  assetFilter,
  // Time range filters
  fromTimestamp: 1704067200n, // Unix timestamp
  toTimestamp: 1735689600n, // Unix timestamp
  // Pagination
  offset: 0,
  limit: 50,
  // Sort order (true = oldest first, false = newest first)
  sortAscending: false
})
const payments = response.payments

Flutter

// Filter by asset (Bitcoin or Token)
AssetFilter assetFilter = AssetFilter.token(tokenIdentifier: "token_identifier_here");
// To filter by Bitcoin instead:
// AssetFilter assetFilter = AssetFilter.bitcoin();

ListPaymentsRequest request = ListPaymentsRequest(
  // Filter by payment type
  typeFilter: [PaymentType.send, PaymentType.receive],
  // Filter by status
  statusFilter: [PaymentStatus.completed],
  assetFilter: assetFilter,
  // Time range filters
  fromTimestamp: BigInt.from(1704067200), // Unix timestamp
  toTimestamp: BigInt.from(1735689600),   // Unix timestamp
  // Pagination
  offset: 0,
  limit: 50,
  // Sort order (true = oldest first, false = newest first)
  sortAscending: false,
);
ListPaymentsResponse response = await sdk.listPayments(request: request);
List<Payment> payments = response.payments;

Python

# Filter by asset (Bitcoin or Token)
asset_filter = AssetFilter.TOKEN(token_identifier="token_identifier_here")
# To filter by Bitcoin instead:
# asset_filter = AssetFilter.BITCOIN

request = ListPaymentsRequest(
    # Filter by payment type
    type_filter=[PaymentType.SEND, PaymentType.RECEIVE],
    # Filter by status
    status_filter=[PaymentStatus.COMPLETED],
    asset_filter=asset_filter,
    # Time range filters
    from_timestamp=1704067200,  # Unix timestamp
    to_timestamp=1735689600,    # Unix timestamp
    # Pagination
    offset=0,
    limit=50,
    # Sort order (true = oldest first, false = newest first)
    sort_ascending=False
)
response = await sdk.list_payments(request=request)
payments = response.payments

// Filter by asset (Bitcoin or Token)
tokenIdentifier := "token_identifier_here"
var assetFilter breez_sdk_spark.AssetFilter = breez_sdk_spark.AssetFilterToken{TokenIdentifier: &tokenIdentifier}
// To filter by Bitcoin instead:
// var assetFilter breez_sdk_spark.AssetFilter = breez_sdk_spark.AssetFilterBitcoin

// Filter options
typeFilter := []breez_sdk_spark.PaymentType{
    breez_sdk_spark.PaymentTypeSend,
    breez_sdk_spark.PaymentTypeReceive,
}
statusFilter := []breez_sdk_spark.PaymentStatus{
    breez_sdk_spark.PaymentStatusCompleted,
}
fromTimestamp := uint64(1704067200) // Unix timestamp
toTimestamp := uint64(1735689600)   // Unix timestamp
offset := uint32(0)
limit := uint32(50)
sortAscending := false

request := breez_sdk_spark.ListPaymentsRequest{
    TypeFilter:    &typeFilter,    // Filter by payment type
    StatusFilter:  &statusFilter,  // Filter by status
    AssetFilter:   &assetFilter,   // Filter by asset (Bitcoin or Token)
    FromTimestamp: &fromTimestamp, // Time range filters
    ToTimestamp:   &toTimestamp,   // Time range filters
    Offset:        &offset,        // Pagination
    Limit:         &limit,         // Pagination
    SortAscending: &sortAscending, // Sort order (true = oldest first, false = newest first)
}
response, err := sdk.ListPayments(request)

if sdkErr := err.(*breez_sdk_spark.SdkError); sdkErr != nil {
    return nil, err
}

payments := response.Payments

Get Payment API docs

You can also retrieve a single payment using the payment id:

Rust

let payment_id = "<payment id>".to_string();
let response = sdk.get_payment(GetPaymentRequest { payment_id }).await?;
let payment = response.payment;

Swift

let paymentId = "<payment id>"
let response = try await sdk.getPayment(
    request: GetPaymentRequest(paymentId: paymentId)
)
let payment = response.payment

Kotlin

try {
    val paymentId = "<payment id>";
    val response = sdk.getPayment(GetPaymentRequest(paymentId))
    val payment = response.payment
} catch (e: Exception) {
    // handle error
}

Javascript

const paymentId = '<payment id>'
const response = await sdk.getPayment({
  paymentId
})
const payment = response.payment

React Native

const paymentId = '<payment id>'
const response = await sdk.getPayment({
  paymentId
})
const payment = response.payment

Flutter

String paymentId = "<payment id>";
GetPaymentRequest request = GetPaymentRequest(paymentId: paymentId);
GetPaymentResponse response = await sdk.getPayment(request: request);
Payment payment = response.payment;

Python

payment_id = "<payment id>"
response = await sdk.get_payment(
    request=GetPaymentRequest(payment_id=payment_id)
)
payment = response.payment

paymentId := "<payment id>"
request := breez_sdk_spark.GetPaymentRequest{
    PaymentId: paymentId,
}
response, err := sdk.GetPayment(request)

if sdkErr := err.(*breez_sdk_spark.SdkError); sdkErr != nil {
    return nil, err
}

payment := response.Payment

Keyboard shortcuts

Breez SDK - Nodeless (Spark)

Listing payments API docs

Filtering Payments

Get Payment API docs