Get an outgoing payment

The Get an Outgoing Payment API lets you get the latest state of an outgoing payment resource.

Using the ID of the payment resource, a client can determine whether the payment is active, pending payment, or complete, and get the receive, debit, and sent amount values.

The code snippets below let an authorized client retrieve the state and details of a specific outgoing payment resource.

Before you begin

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

Get the state of an outgoing payment

Authenticated client required

TypeScript/NodeJS

Prerequisites

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: WALLET_ADDRESS,
  privateKey: PRIVATE_KEY_PATH,
  keyId: KEY_ID
})

// Get outgoing payment
const outgoingPayment = await client.outgoingPayment.get({
  url: OUTGOING_PAYMENT_URL,
  accessToken: OUTGOING_PAYMENT_ACCESS_TOKEN
})

// Output
console.log('OUTGOING PAYMENT:', outgoingPayment)

For TypeScript, run tsx path/to/directory/index.ts. View full TS source

For JavaScript, run node path/to/directory/index.js. View full JS source

Rust

Prerequisites

// Import dependencies
use open_payments::client::api::AuthenticatedResources;
use open_payments::snippets::utils::{create_authenticated_client, get_env_var, load_env};

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

// Get outgoing payment
let access_token = get_env_var("OUTGOING_PAYMENT_ACCESS_TOKEN")?;
let outgoing_payment_url = get_env_var("OUTGOING_PAYMENT_URL")?;

let payment = client
    .outgoing_payments()
    .get(&outgoing_payment_url, Some(&access_token))
    .await?;

// Output
println!("Outgoing payment: {payment:#?}");

View full source

PHP

Prerequisites

// 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 outgoing payment
$outgoingPayment = $opClient->outgoingPayment()->get(
    [
        'access_token' => $OUTGOING_PAYMENT_GRANT_ACCESS_TOKEN,
        'url' => $OUTGOING_PAYMENT_URL
    ]
);

// Output
echo 'OUTGOING PAYMENT: ' . PHP_EOL . print_r($outgoingPayment, true);

View full source

Go

Prerequisites

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)
  }

  // Get outgoing payment
  outgoingPayment, err := client.OutgoingPayment.Get(context.TODO(), op.OutgoingPaymentGetParams{
    URL:         OUTGOING_PAYMENT_URL,
    AccessToken: OUTGOING_PAYMENT_ACCESS_TOKEN,
  })
  if err != nil {
    log.Fatalf("Error fetching outgoing payment: %v\n", err)
  }

  // Output
  outgoingPaymentJSON, err := json.MarshalIndent(outgoingPayment, "", "  ")
  if err != nil {
    log.Fatalf("Error marshaling outgoing payment: %v\n", err)
  }
  fmt.Println("OUTGOING PAYMENT:", string(outgoingPaymentJSON))
}

Java

Prerequisites

// 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));

// Create quote
var quoteRequest = client.auth().grant().quote(senderWallet);
var quote = client.quote().create(quoteRequest.getAccess().getToken(), senderWallet, incomingPayment, Optional.empty(), Optional.empty());

// Create outgoing payment from quote
var urlToOpen = "https://example.com/redirect?paymentId=1234";

var opContinueInteract = client.auth().grant().continuation(
senderWallet,
quote.getDebitAmount(),
URI.create(urlToOpen),
"test"
);

// USER APPROVES REQUEST

// Grant: Finalize/Continue
var finalized = client.auth().grant().finalize(opContinueInteract, "Reference from USER interaction.");

// Outgoing payment (The token will be extracted from [finalized])
var finalizedOutgoingPayment = client.payment().createOutgoing(finalized, senderWallet, quote);

// Retrieve the created outgoing payment (fetch by ID)
var outgoingPaymentFetched = client.payment().getOutgoing(finalizedOutgoingPayment.getId(), grantRequest);

// Output
log.info("OUTGOING_PAYMENT: {}", outgoingPaymentFetched);

.NET

Prerequisites

// Import dependencies
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using OpenPayments.Sdk.Clients;
using OpenPayments.Sdk.Extensions;
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 outgoing payment
var outgoingPayment = await client.GetOutgoingPaymentAsync(
    new AuthRequestArgs
    {
        Url = new Uri(OUTGOING_PAYMENT_URL),
        AccessToken = OUTGOING_PAYMENT_ACCESS_TOKEN,
    }
);

// Output
Console.WriteLine($"OUTGOING PAYMENT: {JsonConvert.SerializeObject(outgoingPayment, Formatting.Indented)}");

View full source

References

• API specification