List incoming payments

The List Incoming Payments API lets you list all incoming payments on a wallet address.

After one or more incoming payment resources are created, a client can look up active and pending payments on the wallet address.

The code snippets below let an authorized client retrieve the first 10 incoming payments on a given wallet address.

Before you begin

We recommend you create an account on the Interledger test network. Creating an account allows you to test your client against the Open Payments APIs by using an ILP-enabled wallet funded with play money.

List all incoming payments on a wallet address

Authenticated client required

TypeScript/NodeJS

Prerequisites(opens in a new tab)

Initial configuration

If you’re using JavaScript, only do the first step.

1. Add "type": "module" to package.json.

2. Add the following to tsconfig.json

   {
     "compilerOptions": {
       "target": "ES2022",
       "module": "ES2022"
     }
   }

// Import dependencies
import { createAuthenticatedClient } from '@interledger/open-payments'

// Initialize client
const client = await createAuthenticatedClient({
  walletAddressUrl: CLIENT_WALLET_ADDRESS,
  privateKey: PRIVATE_KEY_PATH,
  keyId: KEY_ID
})

// Get wallet address information
const walletAddress = await client.walletAddress.get({
  url: WALLET_ADDRESS
})

// List incoming payments
const incomingPayments = await client.incomingPayment.list(
  {
    url: walletAddress.resourceServer,
    walletAddress: WALLET_ADDRESS,
    accessToken: INCOMING_PAYMENT_ACCESS_TOKEN
  },
  {
    first: 10,
    last: undefined,
    cursor: undefined,
    'wallet-address': WALLET_ADDRESS
  }
)

// Output
console.log('INCOMING PAYMENTS:', JSON.stringify(incomingPayments, null, 2))

Rust

Prerequisites(opens in a new tab)

// Import dependencies
use open_payments::client::api::AuthenticatedResources;
use open_payments::client::utils::get_resource_server_url;

// Initialize client
let client = create_authenticated_client()?;

// List incoming payments
let access_token = get_env_var("INCOMING_PAYMENT_ACCESS_TOKEN")?;

let wallet_address_url = get_env_var("WALLET_ADDRESS_URL")?;
let resource_server_url = get_resource_server_url(&wallet_address_url)?;
let response = client
    .incoming_payments()
    .list(
        &resource_server_url,
        &wallet_address_url,
        None,
        Some(10),
        None,
        Some(&access_token),
    )
    .await?;

// Output
println!("Incoming payments: {:#?}", response.result);
println!("Pagination info: {:#?}", response.pagination);

if response.pagination.has_next_page {
    if let Some(end_cursor) = response.pagination.end_cursor {
        let next_page = client
            .incoming_payments()
            .list(
                &resource_server_url,
                &wallet_address_url,
                Some(&end_cursor),
                Some(10),
                None,
                Some(&access_token),
            )
            .await?;
        println!("Next page of incoming payments: {:#?}", next_page.result);
    }
}

PHP

Prerequisites(opens in a new tab)

// Import dependencies
use OpenPayments\AuthClient;
use OpenPayments\Config\Config;

// Initialize client
$config = new Config(
    $WALLET_ADDRESS,
    $PRIVATE_KEY,
    $KEY_ID
);
$opClient = new AuthClient($config);

// Get wallet address information
$wallet = $opClient->walletAddress()->get([
    'url' => $config->getWalletAddressUrl()
]);

// List incoming payments
$incomingPaymentsList = $opClient->incomingPayment()->list(
    [
        'url' => $wallet->resourceServer,
        'access_token' => $INCOMING_PAYMENT_GRANT_ACCESS_TOKEN
    ],
    [
        'wallet-address' => $config->getWalletAddressUrl(),
        'first' => 10
    ]
);

// Output
echo 'INCOMING PAYMENTS ' . PHP_EOL . print_r($incomingPaymentsList, true);

Go

Prerequisites(opens in a new tab)

package main

// Import dependencies
import (
  "context"
  "encoding/json"
  "fmt"
  "log"

  op "github.com/interledger/open-payments-go"
)

func main() {
  // Initialize client
  client, err := op.NewAuthenticatedClient(WALLET_ADDRESS_URL, PRIVATE_KEY_BASE_64, KEY_ID)
  if err != nil {
    log.Fatalf("Error creating authenticated client: %v\n", err)
  }

  // List incoming payments
  incomingPayments, err := client.IncomingPayment.List(context.TODO(), op.IncomingPaymentListParams{
    BaseURL:       RESOURCE_SERVER_URL,
    AccessToken:   INCOMING_PAYMENT_ACCESS_TOKEN,
    WalletAddress: WALLET_ADDRESS_URL,
    Pagination: op.Pagination{
      First: "10",
    },
  })
  if err != nil {
    log.Fatalf("Error listing incoming payments: %v\n", err)
  }

  // Output
  incomingPaymentsJSON, err := json.MarshalIndent(incomingPayments, "", "  ")
  if err != nil {
    log.Fatalf("Error marshaling incoming payments: %v\n", err)
  }
  fmt.Println("INCOMING PAYMENTS:", string(incomingPaymentsJSON))
}

Java

Prerequisites(opens in a new tab)

// Import dependencies
import org.interledger.openpayments.httpclient.OpenPaymentsHttpClient;
import org.interledger.openpayments.IOpenPaymentsClient;

// Initialize client
var client = OpenPaymentsHttpClient.defaultClient(
"WalletAddress",
"PrivateKeyPEM",
"KeyId"
);

// Get wallet address information
var receiverWallet = client.walletAddress().get("https://cloudninebank.example.com/merchant");
var senderWallet = client.walletAddress().get("https://cloudninebank.example.com/customer");

// Create incoming payment
var grantRequest = client.auth().grant().incomingPayment(receiverWallet);
var incomingPayment = client.payment().createIncoming(receiverWallet, grantRequest, BigDecimal.valueOf(11.25));

// Retrieve the created incoming payments (by walletAddress)
var incomingPaymentsFetched = client.payment().getIncomingPayments(senderWallet, senderWallet.getId(), grantRequest);

// Output
log.info("INCOMING_PAYMENT_RESULT: {}", incomingPaymentsFetched.getResult().size());
incomingPaymentsFetched.getResult().forEach(p -> log.info("INCOMING_PAYMENT: {}", p));

.NET

Prerequisites(opens in a new tab)

// Import dependencies
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using OpenPayments.Sdk.Clients;
using OpenPayments.Sdk.Extensions;
using OpenPayments.Sdk.Generated.Resource;
using OpenPayments.Sdk.HttpSignatureUtils;

// Initialize client
var client = new ServiceCollection()
    .UseOpenPayments(opts =>
    {
        opts.UseAuthenticatedClient = true;
        opts.KeyId = CLIENT_ID;
        opts.PrivateKey = KeyUtils.LoadPem(CLIENT_SECRET);
        opts.ClientUrl = new Uri(CLIENT_WALLET_ADDRESS);
    })
    .BuildServiceProvider()
    .GetRequiredService<IAuthenticatedClient>();

// Get wallet address information
var walletAddress = await client.GetWalletAddressAsync(WALLET_ADDRESS);

// Create Incoming Payment
var list = await client.ListIncomingPaymentsAsync(
    new AuthRequestArgs
    {
        Url = walletAddress.ResourceServer,
        AccessToken = INCOMING_PAYMENT_ACCESS_TOKEN,
    },
    new ListIncomingPaymentQuery
    {
        WalletAddress = walletAddress.Id.ToString(),
        First = 10,
        Last = null,
        Cursor = null,
    }
);

// Output
Console.WriteLine($"INCOMING PAYMENTS: {JsonConvert.SerializeObject(list, Formatting.Indented)}");

References

• Resource server API reference