Listing payments API docs

To view your payment history you can list all the sent and received payments made.

Rust

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

Swift

let payments = try? sdk.listPayments(req: ListPaymentsRequest())

Kotlin

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

React Native

const payments = await listPayments({})

Dart

ListPaymentsRequest req = ListPaymentsRequest();
List<Payment> paymentsList = await breezSDKLiquid.instance!.listPayments(req: req);

Python

sdk.list_payments(ListPaymentsRequest())

if payments, err := sdk.ListPayments(breez_sdk_liquid.ListPaymentsRequest{}); err == nil {
    log.Printf("%#v", payments)
}

try
{
    var payments = sdk.ListPayments(new ListPaymentsRequest());
}
catch (Exception)
{
    // Handle error
}

Filtering Payments

When listing payment you can also filter and page the list results, by:

Type and timestamp

Rust

let payments = sdk
    .list_payments(&ListPaymentsRequest {
        filters: Some(vec![PaymentType::Send]),
        states: None,
        from_timestamp: Some(1696880000),
        to_timestamp: Some(1696959200),
        offset: Some(0),
        limit: Some(50),
        details: None,
        sort_ascending: None,
    })
    .await?;

Swift

let payments = try? sdk.listPayments(
    req: ListPaymentsRequest(
        filters: [.send],
        fromTimestamp: 1696880000,
        toTimestamp: 1696959200,
        offset: 0,
        limit: 50
    ))

Kotlin

try {
    val payments = sdk.listPayments(
        ListPaymentsRequest(
            listOf(PaymentType.SEND),
            fromTimestamp = 1696880000,
            toTimestamp = 1696959200,
            offset = 0u,
            limit = 50u
        ))
} catch (e: Exception) {
    // handle error
}

React Native

try {
  const payments = await listPayments({
    filters: [PaymentType.SEND],
    fromTimestamp: 1696880000,
    toTimestamp: 1696959200,
    offset: 0,
    limit: 50
  })
} catch (err) {
  console.error(err)
}

Dart

ListPaymentsRequest req = ListPaymentsRequest(
  filters: [PaymentType.send],
  fromTimestamp: 1696880000,
  toTimestamp: 1696959200,
  offset: 0,
  limit: 50,
);
List<Payment> paymentsList = await breezSDKLiquid.instance!.listPayments(req: req);

Python

req = ListPaymentsRequest(
    [PaymentType.SEND], 
    from_timestamp = 1696880000, 
    to_timestamp = 1696959200, 
    offset = 0,
    limit = 50)
sdk.list_payments(req)

filters := []breez_sdk_liquid.PaymentType{breez_sdk_liquid.PaymentTypeSend}
fromTimestamp := int64(1696880000)
toTimestamp := int64(1696959200)
limit := uint32(50)
offset := uint32(0)
listPaymentsRequest := breez_sdk_liquid.ListPaymentsRequest{
    Filters:       &filters,
    FromTimestamp: &fromTimestamp,
    ToTimestamp:   &toTimestamp,
    Offset:        &offset,
    Limit:         &limit,
}
if payments, err := sdk.ListPayments(listPaymentsRequest); err == nil {
    log.Printf("%#v", payments)
}

try
{
    var payments = sdk.ListPayments(
        new ListPaymentsRequest(
            new() { PaymentType.Send },
            fromTimestamp: 1696880000,
            toTimestamp: 1696959200,
            offset: 0,
            limit: 50
        ));
}
catch (Exception)
{
    // Handle error
}

Bitcoin address

Rust

let address = Some("<Bitcoin address>".to_string());
let payments = sdk
    .list_payments(&ListPaymentsRequest {
        filters: None,
        states: None,
        from_timestamp: None,
        to_timestamp: None,
        offset: None,
        limit: None,
        details: Some(ListPaymentDetails::Bitcoin { address }),
        sort_ascending: None,
    })
    .await?;

Swift

let address = "<Bitcoin address>"
let payments = try? sdk.listPayments(
    req: ListPaymentsRequest(
        details: ListPaymentDetails.bitcoin(address: address)
    ))

Kotlin

try {
    val address = "<Bitcoin address>"
    val payments = sdk.listPayments(
        ListPaymentsRequest(
            details = ListPaymentDetails.Bitcoin(address)
        ))
} catch (e: Exception) {
    // handle error
}

React Native

try {
  const payments = await listPayments({
    details: {
      type: ListPaymentDetailsVariant.BITCOIN,
      address: '<Bitcoin address>'
    }
  })
} catch (err) {
  console.error(err)
}

Dart

String address = "<Bitcoin address>";
ListPaymentsRequest req = ListPaymentsRequest(
  details: ListPaymentDetails_Bitcoin(address: address),
);
List<Payment> paymentsList = await breezSDKLiquid.instance!.listPayments(req: req);

Python

address = "<Bitcoin address>"
req = ListPaymentsRequest(
    details = ListPaymentDetails.BITCOIN(address))
sdk.list_payments(req)

address := "<Bitcoin address>"
var details breez_sdk_liquid.ListPaymentDetails = breez_sdk_liquid.ListPaymentDetailsBitcoin{
    Address: &address,
}
listPaymentsRequest := breez_sdk_liquid.ListPaymentsRequest{
    Details: &details,
}
if payments, err := sdk.ListPayments(listPaymentsRequest); err == nil {
    log.Printf("%#v", payments)
}

try
{
    var address = "<Bitcoin address>";
    var payments = sdk.ListPayments(
        new ListPaymentsRequest(
            details: new ListPaymentDetails.Bitcoin(address)
        ));
}
catch (Exception)
{
    // Handle error
}

Liquid destination

Rust

    let destination = Some("<Liquid BIP21 or address>".to_string());
    let payments = sdk
        .list_payments(&ListPaymentsRequest {
            filters: None,
            states: None,
            from_timestamp: None,
            to_timestamp: None,
            offset: None,
            limit: None,
            details: Some(ListPaymentDetails::Liquid {
                asset_id: None,
                destination,
            }),
            sort_ascending: None,
        })
        .await?;

    Ok(payments)
}

Swift

let destination = "<Liquid BIP21 or address>"
let payments = try? sdk.listPayments(
    req: ListPaymentsRequest(
        details: ListPaymentDetails.liquid(assetId: nil, destination: destination)
    ))

Kotlin

try {
    val destination = "<Liquid BIP21 or address>"
    val payments = sdk.listPayments(
        ListPaymentsRequest(
            details = ListPaymentDetails.Liquid(assetId = null, destination = destination)
        ))
} catch (e: Exception) {
    // handle error
}

React Native

try {
  const payments = await listPayments({
    details: {
      type: ListPaymentDetailsVariant.LIQUID,
      destination: '<Liquid BIP21 or address>'
    }
  })
} catch (err) {
  console.error(err)
}

Dart

String destination = "<Liquid BIP21 or address>";
ListPaymentsRequest req = ListPaymentsRequest(
  details: ListPaymentDetails_Liquid(destination: destination),
);
List<Payment> paymentsList = await breezSDKLiquid.instance!.listPayments(req: req);

Python

destination = "<Liquid BIP21 or address>"
req = ListPaymentsRequest(
    details = ListPaymentDetails.LIQUID(destination=destination))
sdk.list_payments(req)

destination := "<Liquid BIP21 or address>"
var details breez_sdk_liquid.ListPaymentDetails = breez_sdk_liquid.ListPaymentDetailsLiquid{
    Destination: &destination,
}
listPaymentsRequest := breez_sdk_liquid.ListPaymentsRequest{
    Details: &details,
}
if payments, err := sdk.ListPayments(listPaymentsRequest); err == nil {
    log.Printf("%#v", payments)
}

try
{
    var destination = "<Liquid BIP21 or address>";
    var payments = sdk.ListPayments(
        new ListPaymentsRequest(
            details: new ListPaymentDetails.Liquid(assetId: null, destination: destination)
        ));
}
catch (Exception)
{
    // Handle error
}

Get Payment API docs

You can also retrieve a single Lightning payment using one of the following identifier kinds:

Lightning payment hash
Swap ID or its SHA256 hash

Rust

let payment_hash = "<payment hash>".to_string();
let payment = sdk
    .get_payment(&GetPaymentRequest::PaymentHash { payment_hash })
    .await?;

let swap_id = "<swap id>".to_string();
let payment = sdk
    .get_payment(&GetPaymentRequest::SwapId { swap_id })
    .await?;

Swift

let paymentHash = "<payment hash>"
let paymentByHash = try? sdk.getPayment(
    req: GetPaymentRequest.paymentHash(paymentHash: paymentHash)
)

let swapId = "<swap id>"
let paymentBySwapId = try? sdk.getPayment(
    req: GetPaymentRequest.swapId(swapId: swapId)
)

Kotlin

try {
    val paymentHash = "<payment hash>";
    val paymentByHash = sdk.getPayment(GetPaymentRequest.PaymentHash(paymentHash))

    val swapId = "<swap id>";
    val paymentBySwapId = sdk.getPayment(GetPaymentRequest.SwapId(swapId))
} catch (e: Exception) {
    // handle error
}

React Native

const paymentHash = '<payment hash>'
const paymentByHash = await getPayment({
  type: GetPaymentRequestVariant.PAYMENT_HASH,
  paymentHash
})

const swapId = '<swap id>'
const paymentBySwapId = await getPayment({
  type: GetPaymentRequestVariant.SWAP_ID,
  swapId
})

Dart

String paymentHash = "<payment hash>";
GetPaymentRequest reqByHash = GetPaymentRequest.paymentHash(paymentHash: paymentHash);
Payment? paymentByHash = await breezSDKLiquid.instance!.getPayment(req: reqByHash);

String swapId = "<swap id>";
GetPaymentRequest reqBySwapId = GetPaymentRequest.swapId(swapId: swapId);
Payment? paymentBySwapId = await breezSDKLiquid.instance!.getPayment(req: reqBySwapId);

Python

payment_hash = "<payment hash>"
sdk.get_payment(GetPaymentRequest.PAYMENT_HASH(payment_hash))

swap_id = "<swap id>"
sdk.get_payment(GetPaymentRequest.SWAP_ID(swap_id))

paymentHash := "<payment hash>"
reqByPaymentHash := breez_sdk_liquid.GetPaymentRequestPaymentHash{
    PaymentHash: paymentHash,
}
if payment, err := sdk.GetPayment(reqByPaymentHash); err == nil {
    log.Printf("%#v", payment)
}

swapId := "<swap id>"
reqBySwapId := breez_sdk_liquid.GetPaymentRequestSwapId{
    SwapId: swapId,
}
if payment, err := sdk.GetPayment(reqBySwapId); err == nil {
    log.Printf("%#v", payment)
}

try
{
    var paymentHash = "<payment hash>";
    var paymentByHash = sdk.GetPayment(
        new GetPaymentRequest.PaymentHash(paymentHash)
    );

    var swapId = "<swap id>";
    var paymentBySwapId = sdk.GetPayment(
        new GetPaymentRequest.SwapId(swapId)
    );
}
catch (Exception)
{
    // Handle error
}

Breez SDK - Nodeless

Listing payments API docs

Filtering Payments

Type and timestamp

Bitcoin address

Liquid destination

Get Payment API docs