Choose a merchant account

curl --get "https://api.sumup.com/v0.1/memberships" \
  --header "Authorization: Bearer ${SUMUP_ACCESS_TOKEN}" \
  --data-urlencode "kind=merchant" \
  --data-urlencode "status=accepted" \
  --data-urlencode "limit=25" \
  --data-urlencode "offset=0"

import SumUp from "@sumup/sdk";

const client = new SumUp({ apiKey: process.env.SUMUP_ACCESS_TOKEN! });
const accounts = await client.memberships.list({
  kind: "merchant",
  status: "accepted",
  limit: 25,
  offset: 0,
});
console.log(accounts);

import os

from sumup import Sumup

client = Sumup(api_key=os.environ["SUMUP_ACCESS_TOKEN"])
accounts = client.memberships.list(
    kind="merchant",
    status="accepted",
    limit=25,
    offset=0,
)
print(accounts)

<?php

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

$client = new \SumUp\SumUp(getenv('SUMUP_ACCESS_TOKEN'));
$query = new \SumUp\Services\MembershipsListParams();
$query->kind = 'merchant';
$query->status = 'accepted';
$query->limit = 25;
$query->offset = 0;
$accounts = $client->memberships()->list($query);
var_dump($accounts);

package main

import (
	"context"
	"fmt"
	"log"
	"os"

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

func main() {
	client := sumup.NewClient(sumupclient.WithAPIKey(os.Getenv("SUMUP_ACCESS_TOKEN")))
	kind := sumup.ResourceType("merchant")
	status := sumup.MembershipStatusAccepted
	limit, offset := 25, 0
	accounts, err := client.Memberships.List(context.Background(), sumup.MembershipsListParams{
		Kind:   &kind,
		Status: &status,
		Limit:  &limit,
		Offset: &offset,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", accounts)
}

import com.sumup.sdk.SumUpClient;
import com.sumup.sdk.clients.MembershipsClient.ListMembershipsQueryParams;
import com.sumup.sdk.models.MembershipStatus;

public class Main {
  public static void main(String[] args) throws Exception {
    var client = new SumUpClient(System.getenv("SUMUP_ACCESS_TOKEN"));
    var accounts = client.memberships().list(
        new ListMembershipsQueryParams()
            .kind("merchant")
            .status(MembershipStatus.ACCEPTED)
            .limit(25L)
            .offset(0L));
    System.out.println(accounts);
  }
}

using System;
using SumUp;

using var client = new SumUpClient(); // Reads SUMUP_ACCESS_TOKEN.
var response = await client.Memberships.ListAsync(new MembershipsListOptions
{
    Kind = "merchant",
    Status = MembershipStatus.Accepted,
    Limit = 25,
    Offset = 0,
});
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(response.Data));

use sumup::{
    resources::{common::MembershipStatus, memberships::ListParams},
    Authorization, Client,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::default().with_authorization(Authorization::api_key(
        std::env::var("SUMUP_ACCESS_TOKEN")?,
    ));
    let accounts = client
        .memberships()
        .list(ListParams {
            kind: Some("merchant".into()),
            status: Some(MembershipStatus::Accepted),
            limit: Some(25),
            offset: Some(0),
            ..Default::default()
        })
        .await?;
    println!("{accounts:#?}");
    Ok(())
}