Get available payment methods

GET/v0.1/merchants/{merchant_code}/payment-methods

Lists the payment methods available to the merchant for checkout payments. Use the optional amount and currency filters to check eligibility for a particular payment before presenting payment options to the payer.

Authorization

Use one of the following alternatives:

apiKey
oauth2

Authorization guide

Path parameters

merchant_codestringrequired
Short unique identifier for the merchant.

Example: "MH4H92C7"

Query parameters

amountnumber
Payment amount in major units, for example 9.99 for EUR 9.99. When filtering by amount, also provide currency.

Example: 9.99
currencystring
Three-letter ISO 4217 currency code for which the payment methods should be eligible, for example EUR.

Example: "EUR"

Responses

200application/json

Available payment methods

available_payment_methodsarray<object>
Payment methods available to the merchant for the checkout.

Example: [{"id":"apple_pay"},{"id":"blik"}]
Show 1 property
- idstringrequired
  Unique identifier of the payment method.
  
  Example: "qr_code_pix"

400application/json

The request is invalid for the submitted query parameters.

titlestring
Short title of the error.

Example: "Bad Request"
detailsstring
Details of the error.

Example: "One or more of the parameters are invalid."
statusnumber
HTTP status code for the error.

Example: 400
failed_constraintsarray<object>
List of violated validation constraints.

Example: [{"message":"Currency must also be specified when filtering by amount","reference":"currency"}]
Show 2 properties
- messagestring
  Human-readable description of the violated constraint.
  
  Example: "Currency must also be specified when filtering by amount"
- referencestring
  Name of the field that violated the constraint.
  
  Example: "currency"

GET

Get available payment methods

Code sample

curl --request GET \
  --url https://api.sumup.com/v0.1/merchants/MH4H92C7/payment-methods \
  --header 'Authorization: Bearer <token>'

import SumUp from "@sumup/sdk";

async function main() {
  const client = new SumUp({ apiKey: "sup_sk_your_api_key" });

  const result = await client.checkouts.listAvailablePaymentMethods(
    "MH4H92C7",
    {
      "amount": 9.99
    }
  );
  console.log(result);
}

main().catch(console.error);

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using SumUp;

public static class Program
{
    public static async Task Main()
    {
        using var client = new SumUpClient();
        var response = await client.Checkouts.ListAvailablePaymentMethodsAsync(
            "your-merchant-code",
            new CheckoutsListAvailablePaymentMethodsOptions
            {
                Amount = 10.00m,
                Currency = "example",
            });

        Console.WriteLine(response.StatusCode);
    }
}

import com.sumup.sdk.SumUpClient;

public final class GetPaymentMethodsSample {
  public static void main(String[] args) throws Exception {
    var client = new SumUpClient();

    var result = client.checkouts().listAvailablePaymentMethods(
            "MH4H92C7"
        );
    System.out.println(result);
  }
}

import os

import sumup

client = sumup.Sumup(api_key=os.environ["SUMUP_API_KEY"])
result = client.checkouts.list_available_payment_methods(
    "MH4H92C7",
    amount=9.99,
    currency="EUR",
)
print(result)

<?php

declare(strict_types=1);

require __DIR__ . '/vendor/autoload.php';

$sumup = new \SumUp\SumUp('sup_sk_your_api_key');

$queryParams = new \SumUp\Services\CheckoutsListAvailablePaymentMethodsParams();
$queryParams->amount = 9.99;
$queryParams->currency = 'EUR';

$result = $sumup->checkouts()->listAvailablePaymentMethods(
    'MH4H92C7',
    $queryParams,
);

var_dump($result);

package main

import (
	"context"
	"fmt"

	"github.com/sumup/sumup-go"
)

func main() {
	client := sumup.NewClient()
	result, err := client.Checkouts.ListAvailablePaymentMethods(context.TODO(), "MH4H92C7", sumup.CheckoutsListAvailablePaymentMethodsParams{
		Amount:   new(float64(9.99)),
		Currency: new("EUR"),
	})
	if err != nil {
		panic(err.Error())
	}

	fmt.Printf("%+v\n", result)
}

use sumup::{Authorization, Client};
#[tokio::main]
async fn main() {
    let client = Client::default()
        .with_authorization(Authorization::api_key("sup_sk_test_..."));
    let response = client
        .checkouts()
        .list_available_payment_methods(
            "MERCHANT_CODE",
            sumup::resources::checkouts::ListAvailablePaymentMethodsParams::builder()
                .build(),
        )
        .await
        .expect("list_available_payment_methods request failed");
    println!("{response:#?}");
}

Response example

{
  "available_payment_methods": [
    {
      "id": "apple_pay"
    },
    {
      "id": "blik"
    }
  ]
}

{
  "failed_constraints": [
    {
      "message": "Currency must also be specified when filtering by amount",
      "reference": "currency"
    }
  ],
  "status": 400,
  "title": "Bad Request"
}