Step 2: Get a list of payment options

Next, you can use the payment options endpoint to determine which payment options can be shown at checkout for the combination of amount, currency, country, cart_items and metadata should be displayed in your checkout. The payment options API endpoint makes it easy to get a list of payment options.

using Gr4vy;
using Gr4vy.Models.Components;

var sdk = new Gr4vySDK(
    id: "mattilda",
    server: SDKConfig.Server.Sandbox,
    bearerAuthSource: Auth.WithToken(privateKey),
    merchantAccountId: "example"
);

var res = await sdk.PaymentOptions.ListAsync(paymentOptionRequest: new PaymentOptionRequest() {});

// handle response

package main

import(
	"context"
	gr4vygo "github.com/gr4vy/gr4vy-go"
	"os"
	"github.com/gr4vy/gr4vy-go/models/components"
	"log"
)

func main() {
    ctx := context.Background()

    privateKey := "...."
	withToken := gr4vy.WithToken(privateKey, []JWTScope{ReadAll, WriteAll}, 60)

	s := gr4vy.New(
		gr4vy.WithID("mattilda"),
		gr4vy.WithServer(gr4vy.ServerSandbox),
		gr4vy.WithSecuritySource(withToken),
		gr4vy.WithMerchantAccountID("example"),
	)

    res, err := s.PaymentOptions.List(ctx, components.PaymentOptionRequest{})
    if err != nil {
        log.Fatal(err)
    }
    if res != nil {
        // handle response
    }
}

package hello.world;

import java.lang.Exception;
import com.gr4vy.sdk.BearerSecuritySource;
import com.gr4vy.sdk.Gr4vy;
import com.gr4vy.sdk.Gr4vy.AvailableServers;
import org.openapis.openapi.models.components.PaymentOptionRequest;
import org.openapis.openapi.models.errors.*;
import org.openapis.openapi.models.operations.ListPaymentOptionsResponse;

public class Application {

    public static void main(String[] args) throws Exception {

        Gr4vy sdk = Gr4vy.builder()
                .id("mattilda")
                .server(AvailableServers.SANDBOX)
                .merchantAccountId("example")
                .securitySource(new BearerSecuritySource.Builder(privateKey).build())
            .build();

        ListPaymentOptionsResponse res = sdk.paymentOptions().list()
                .paymentOptionRequest(PaymentOptionRequest.builder()
                    .build())
                .call();

        if (res.paymentOptions().isPresent()) {
            // handle response
        }
    }
}

declare(strict_types=1);

require 'vendor/autoload.php';

use Gr4vy;
use Gr4vy\Auth;

, 
$privateKey = "..."; 

$sdk = Gr4vy\SDK::builder()
    -\u003esetId('mattilda')
    -\u003esetServer('sandbox')
    -\u003esetSecuritySource(Auth::withToken($privateKey))
    -\u003esetMerchantAccountId('example')
    -\u003ebuild();

$paymentOptionRequest = new Gr4vy\PaymentOptionRequest();

$response = $sdk->paymentOptions->list(
    paymentOptionRequest: $paymentOptionRequest
);

if ($response->paymentOptions !== null) {
    // handle response
}

from gr4vy import Gr4vy, auth
import os


with Gr4vy(
    id="mattilda",
    server="production",
    merchant_account_id="example",
    bearer_auth=auth.with_token(open("./private_key.pem").read())
) as g_client:

    res = g_client.payment_options.list(locale="en")

    # Handle response
    print(res)

import { Gr4vy } from "@gr4vy/sdk";

const gr4vy = new Gr4vy({
    server: "sandbox",
    id: "mattilda",
    bearerAuth: withToken({
      privateKey: fs.readFileSync("private_key.pem", "utf8"),
    }),
});

async function run() {
  const result = await gr4vy.paymentOptions.list({});

  console.log(result);
}

run();

This API will automatically use your checkout Flow rules to limit these results.

Each payment option will include the method, icon_url, label and other useful information on supported features that you can use to display the options on your checkout.

{
    "items": [
        {
            "type": "payment-option",
            "method": "card",
            "icon_url": "https://api.sandbox.mattildapayments.com/assets/icons/payment-methods/card.svg",
            "mode": "card",
            "label": "Card",
            "can_store_payment_method": true,
            "can_delay_capture": true,
            "context": {
                "approval_ui": {
                    "height": "589px",
                    "width": "500px"
                },
                "required_fields": {}
            }
        },
        {
            "type": "payment-option",
            "method": "alipay",
            "icon_url": "https://api.sandbox.mattildapayments.com/assets/icons/payment-methods/alipay.svg",
            "mode": "redirect",
            "label": "Alipay",
            "can_store_payment_method": true,
            "can_delay_capture": false,
            "context": {
                "approval_ui": {
                    "height": "589px",
                    "width": "500px"
                },
                "required_fields": {}
            }
        }
    ]
}

This API supports an optional locale that can be set to get the label in your local language.

Your application can now display these payment options on your checkout page. To display the available options and allow your customer to checkout, use each label and icon, and then handle the transaction according to the next step.

We recommend using Secure Fields when working with cards as it reduces the PCI scope of your integration. If you intend to use our API directly for card payments without Secure Fields then you will have to go through your own PCI-DSS level 1 certification.

By implementing the payment options in this way you can fully utilize payment orchestration while having all the flexibility on the design and layout.

Summary

In this step you:

Called the payment options endpoint
Displayed the payment options on your checkout

Getting Started

Integration

Tools

Cloud Vault

Features

Other

Step 2: Get a list of payment options

Summary

​Summary

Summary