---
title: "Card Component integration"
description: "Add cards to an existing Components integration."
url: "https://docs.adyen.com/payment-methods/cards/flutter-component"
source_url: "https://docs.adyen.com/payment-methods/cards/flutter-component.md"
canonical: "https://docs.adyen.com/payment-methods/cards/flutter-component"
last_modified: "2026-05-23T12:56:20+02:00"
language: "en"
---

# Card Component integration

Add cards to an existing Components integration.

[View source](/payment-methods/cards/flutter-component.md)

This page explains how to add cards to your existing Components integration.

## Requirements

Select the [server-side flow](/online-payments/build-your-integration) that your integration uses:

### Tab: Sessions flow

| Requirement          | Description                                                                                                                               |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built a [Flutter Components integration](/online-payments/build-your-integration/sessions-flow?platform=Flutter). |
| **Setup steps**      | Before you begin, [add cards in your Customer Area](/payment-methods/add-payment-methods).                                                |

### Tab: Advanced flow

| Requirement          | Description                                                                                                                               |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | Make sure that you have built a [Flutter Components integration](/online-payments/build-your-integration/advanced-flow?platform=Flutter). |
| **Setup steps**      | Before you begin, [add cards in your Customer Area](/payment-methods/add-payment-methods).                                                |

## API reference

### Tab: Sessions flow

When you [make the `/sessions` request](/online-payments/build-your-integration/sessions-flow?platform=Flutter\&integration=Components#create-a-payment-session), cards does not require any additional fields.

### Tab: Advanced flow

When you [make the `/payments` request](/online-payments/build-your-integration/advanced-flow?platform=Flutter\&integration=Components#make-a-payment), cards does not require any additional fields.

## Components configuration

### Tab: Sessions flow

When you [configure](/online-payments/build-your-integration/sessions-flow?platform=Flutter\&integration=Components#configure) the Component, cards does not require any additional configuration.

### Tab: Advanced flow

When you [configure](/online-payments/build-your-integration/advanced-flow?platform=Flutter\&integration=Components#configure) the Component, cards does not require any additional configuration.

### Optional configuration

You can include the following parameters in the configuration object:

| Parameter                             | Description                                                                                                                                                                                                                                                                 |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `holderNameRequired`                  | Set to **true** to require the cardholder name.                                                                                                                                                                                                                             |
| `addressMode`                         | Specify which address fields are required. Possible values: -**full**: require the full address. -**postalCode**: require the postal code. -**none**: address not required.                                                                                                 |
| `showCvc`                             | Set to **true** to show the security code (CVC/CVV/CID) in the payment form.                                                                                                                                                                                                |
| `supportedCardTypes`                  | A list of [supported card types](/payment-methods/cards/custom-card-integration#supported-card-types) that you recognize.                                                                                                                                                   |
| `socialSecurityNumberFieldVisibility` | Specify if the social security number field shows. Possible values -**show**: show the field. -**hide**: do not show the field.                                                                                                                                             |
| `showStorePaymentMethodField`         | Set to **true** to show the option to store card details for recurring payments.                                                                                                                                                                                            |
| `showCvcForStoredCard`                | Set to **true** to show the security code (CVC/CVV/CID) of stored cards.                                                                                                                                                                                                    |
| `kcpFieldVisibility`                  | For Korean cards, sets if the security field shows in the payment form. Possible values: -**show**: show the field. -**hide**: do not show the field.                                                                                                                       |
| `onBinLookup`                         | Called when the shopper enters the card number. Requires a minimum of 11 digits of the card number to be entered. Returns the following- `brand`: The brands on the card.                                                                                                   |
| `onBinValue`                          | Called when the shopper enters the card number. Returns the following- `binValue`: The first 6 digits of the card number.Requires the [client key](/development-resources/client-side-authentication/migrate-from-origin-key-to-client-key) for client-side authentication. |

You can refer to the [`CardConfiguration` class in Github](https://github.com/Adyen/adyen-flutter/blob/main/lib/src/common/model/payment_method_configurations/card_configuration.dart).

### Tab: Sessions flow

After adding the configuration object for cards, [initialize and show](/online-payments/build-your-integration/sessions-flow?platform=Flutter\&integration=Components#launch-and-show) the Component.

### Tab: Advanced flow

After adding the configuration object for cards, [add the required callbacks](/online-payments/build-your-integration/advanced-flow?platform=Flutter\&integration=Components#launch-and-show).

## Showing debit and credit cards separately

Components can show separate payment forms for debit cards and credit cards. Here are example use cases for this feature:

* In Brazil, Mexico, and Finland, many shoppers use [combo cards](#combo-cards) that can make both debit or credit transactions. Separate forms for **Debit Card** and **Credit Card** lets the shopper choose the type of transaction.
* To accept card payments in [Sweden](#sweden), local legislation requires you to show the debit card payment options before the credit card ones.

### Tab: Sessions flow

When you make a [/sessions](https://docs.adyen.com/api-explorer/Checkout/latest/post/sessions) request from your server, include:

* [splitCardFundingSources](https://docs.adyen.com/api-explorer/Checkout/latest/post/sessions#request-splitCardFundingSources): Set to **true**.

The following example shows how to do this for a shopper in the **Netherlands**, making a **EUR 47.00** payment.

**/sessions request**

```bash
curl https://checkout-test.adyen.com/v70/sessions \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
    "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
    "countryCode": "NL",
    "amount": {
        "currency": "EUR",
        "value": 4700
    },
    "splitCardFundingSources": true
}'
```

### Tab: Advanced flow

Supported from Checkout API v53 or later.

When you make a [/paymentMethods](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods) request from your server, include:

* [splitCardFundingSources](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-splitCardFundingSources): Set to **true**.

The following example shows how to do this for a shopper in the **Netherlands**, making a **EUR 47.00** payment.

**/paymentMethods request**

```bash
curl https://checkout-test.adyen.com/v72/paymentMethods \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
    "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
    "countryCode": "NL",
    "amount": {
        "currency": "EUR",
        "value": 4700
    },
    "splitCardFundingSources": true
}'
```

The response includes the list of available payment methods, with debit and credit cards split into separate objects.

**Response**

```json
{
    ...
    "paymentMethods": [
        {
            "brands": [
                "mc",
                "visa",
                "amex"
            ],
            ...
            "fundingSource": "credit",
            "name": "Credit Card",
            "type": "scheme"
        },
        {
            "brands": [
                "mc",
                 "visa",
                 "amex"
            ],
            "fundingSource": "debit",
            "name": "Debit Card",
            "type": "scheme"
        }
    ]
}
```

### Combo cards

For debit transactions, we highly recommend using [3D Secure](/online-payments/3d-secure) and [automatic capture](/online-payments/capture) due to some issuers' restrictions.

### Sweden

To comply with [local legislation](https://www.regeringen.se/rattsliga-dokument/lagradsremiss/2019/12/presentation-av-betalningssatt-vid-marknadsforing-av-betaltjanster-online), set `countryCode` to **SE** in your request. Components shows the payment form for **Debit Card** before the one for **Credit Card**.

## Card brand recognition

When the shopper is entering their card details, Components tries to recognize the card brand. When successful, Components renders the brand icon and the corresponding input field for the card security code (CVC, CVV, or CID).

### Co-badged cards

Co-badged cards are rendered by the Component according to the [co-badged card regulations for the applicable regions](/online-payments/co-badged-cards-compliance/). This means that Components renders all supported brands, and allows the cardholder to choose their preferred brand.

## Recurring payments

Cards support [tokenization](/online-payments/tokenization) for [one-click](/get-started-with-adyen/adyen-glossary/#one-click-payments), [subscription](/get-started-with-adyen/adyen-glossary/#subscriptions), and [unscheduled card-on-file](/get-started-with-adyen/adyen-glossary#unscheduled-card-on-file-ucof) payments. Refer to [Create tokens](/online-payments/tokenization/create-tokens/) to integrate with our tokenization feature.

We strongly recommend that you ask explicit permission from the shopper if you intend to make future recurring payments. Being transparent about the payment schedule and the charged amount reduces the risk of chargebacks.

Choose which [server-side flow](/online-payments/build-your-integration) your integration uses:

### Tab: Sessions flow

### Store card details

Refer to [Create tokens](/online-payments/tokenization/create-tokens) to create a card token. You do not need to include any additional parameters for cards.

**Create a token for one-click payments**

#### curl

```bash
curl https://checkout-test.adyen.com/v71/sessions \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
    "amount":{
      "currency":"JPY",
      "value": 3000
    },
    "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
    "shopperReference": "YOUR_SHOPPER_REFERENCE",
    "reference": "YOUR_REFERENCE",
    "recurringProcessingModel": "CardOnFile",
    "shopperInteraction": "Ecommerce",
    "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy..",
    "storePaymentMethodMode": "askForConsent"
}'
```

#### Java

```java
// Adyen Java API Library v26.3.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.checkout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.model.RequestOptions;
import com.adyen.service.checkout.*;

// For the live environment, additionally include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("EUR")
  .value(100L);

CreateCheckoutSessionRequest createCheckoutSessionRequest = new CreateCheckoutSessionRequest()
  .reference("YOUR_PAYMENT_REFERENCE")
  .storePaymentMethodMode(CreateCheckoutSessionRequest.StorePaymentMethodModeEnum.ENABLED)
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .countryCode("NL")
  .recurringProcessingModel(CreateCheckoutSessionRequest.RecurringProcessingModelEnum.CARDONFILE)
  .shopperInteraction(CreateCheckoutSessionRequest.ShopperInteractionEnum.ECOMMERCE)
  .returnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..")
  .shopperReference("YOUR_SHOPPER_REFERENCE");

// Send the request
PaymentsApi service = new PaymentsApi(client);
CreateCheckoutSessionResponse response = service.sessions(createCheckoutSessionRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
// Adyen PHP API Library v18.2.1
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CreateCheckoutSessionRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the live environment, additionally include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("EUR")
  ->setValue(100);

$createCheckoutSessionRequest = new CreateCheckoutSessionRequest();
$createCheckoutSessionRequest
  ->setReference("YOUR_PAYMENT_REFERENCE")
  ->setStorePaymentMethodMode("enabled")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setCountryCode("NL")
  ->setRecurringProcessingModel("CardOnFile")
  ->setShopperInteraction("Ecommerce")
  ->setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..")
  ->setShopperReference("YOUR_SHOPPER_REFERENCE");

$requestOptions['idempotencyKey'] = 'UUID';

// Send the request
$service = new PaymentsApi($client);
$response = $service->sessions($createCheckoutSessionRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v17.0.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the live environment, additionally include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "EUR",
  Value = 100
};

CreateCheckoutSessionRequest createCheckoutSessionRequest = new CreateCheckoutSessionRequest
{
  Reference = "YOUR_PAYMENT_REFERENCE",
  StorePaymentMethodMode = CreateCheckoutSessionRequest.StorePaymentMethodModeEnum.Enabled,
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  CountryCode = "NL",
  RecurringProcessingModel = CreateCheckoutSessionRequest.RecurringProcessingModelEnum.CardOnFile,
  ShopperInteraction = CreateCheckoutSessionRequest.ShopperInteractionEnum.Ecommerce,
  ReturnUrl = "https://your-company.example.com/checkout?shopperOrder=12xy..",
  ShopperReference = "YOUR_SHOPPER_REFERENCE"
};

// Send the request
var service = new PaymentsService(client);
var response = service.Sessions(createCheckoutSessionRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v29.0.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const createCheckoutSessionRequest = {
  amount: {
    currency: "JPY",
    value: 3000
  },
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  shopperReference: "YOUR_SHOPPER_REFERENCE",
  reference: "YOUR_REFERENCE",
  recurringProcessingModel: "CardOnFile",
  shopperInteraction: "Ecommerce",
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  storePaymentMethodMode: "askForConsent"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.sessions(createCheckoutSessionRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v10.4.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/checkout"
)
// For the live environment, additionally include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "EUR",
  Value: 100,
}

createCheckoutSessionRequest := checkout.CreateCheckoutSessionRequest{
  Reference: "YOUR_PAYMENT_REFERENCE",
  StorePaymentMethodMode: common.PtrString("enabled"),
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  CountryCode: common.PtrString("NL"),
  RecurringProcessingModel: common.PtrString("CardOnFile"),
  ShopperInteraction: common.PtrString("Ecommerce"),
  ReturnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  ShopperReference: common.PtrString("YOUR_SHOPPER_REFERENCE"),
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.SessionsInput().IdempotencyKey("UUID").CreateCheckoutSessionRequest(createCheckoutSessionRequest)
res, httpRes, err := service.PaymentsApi.Sessions(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.1
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the live environment, additionally include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "amount": {
    "value": 100,
    "currency": "EUR"
  },
  "shopperReference": "YOUR_SHOPPER_REFERENCE",
  "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy..",
  "reference": "YOUR_PAYMENT_REFERENCE",
  "countryCode": "NL",
  "storePaymentMethodMode": "enabled",
  "shopperInteraction": "Ecommerce",
  "recurringProcessingModel": "CardOnFile"
}

# Send the request
result = adyen.checkout.payments_api.sessions(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.1
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the live environment, additionally include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :amount => {
    :value => 100,
    :currency => 'EUR'
  },
  :shopperReference => 'YOUR_SHOPPER_REFERENCE',
  :returnUrl => 'https://your-company.example.com/checkout?shopperOrder=12xy..',
  :reference => 'YOUR_PAYMENT_REFERENCE',
  :countryCode => 'NL',
  :storePaymentMethodMode => 'enabled',
  :shopperInteraction => 'Ecommerce',
  :recurringProcessingModel => 'CardOnFile'
}

# Send the request
result = adyen.checkout.payments_api.sessions(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.0.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "JPY",
  value: 3000
};

const createCheckoutSessionRequest: Types.checkout.CreateCheckoutSessionRequest = {
  reference: "YOUR_REFERENCE",
  storePaymentMethodMode: Types.checkout.CreateCheckoutSessionRequest.StorePaymentMethodModeEnum.AskForConsent,
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.CreateCheckoutSessionRequest.RecurringProcessingModelEnum.CardOnFile,
  shopperInteraction: Types.checkout.CreateCheckoutSessionRequest.ShopperInteractionEnum.Ecommerce,
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  shopperReference: "YOUR_SHOPPER_REFERENCE"
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.sessions(createCheckoutSessionRequest, { idempotencyKey: "UUID" });
```

When a token is created, you receive a [recurring.token.created](https://docs.adyen.com/api-explorer/Tokenization-webhooks/latest/post/recurring.token.created) webhook.

#### Checkout API v69 or earlier

When [creating a token](/online-payments/tokenization/create-tokens) for cards using Checkout API v69 or earlier:

* Use the `enableStoreDetails` [configuration](#optional-configuration) to show a checkbox for your shopper to choose to store their card details.

### Make a one-click payment

[Make a one-click payment](/online-payments/tokenization/make-token-payments#make-a-one-click-payment) using standard tokenization parameters. You do not need to include any additional parameters for cards.

**Make a one-click payment**

#### curl

```bash
curl https://checkout-test.adyen.com/v71/sessions \
-H 'x-API-key: ADYEN_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
     "amount":{
       "value":2000,
       "currency":"USD"
     },
     "reference":"YOUR_PAYMENT_REFERENCE",
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "returnUrl":"https://your-company.example.com/checkout?shopperOrder=12xy..",
     "shopperReference":"YOUR_UNIQUE_SHOPPER_ID",
     "shopperInteraction":"ContAuth",
     "recurringProcessingModel":"CardOnFile"
 }'
```

#### Java

```java
// Adyen Java API Library v39.3.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.checkout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.model.RequestOptions;
import com.adyen.service.checkout.*;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(2000L);

CreateCheckoutSessionRequest createCheckoutSessionRequest = new CreateCheckoutSessionRequest()
  .reference("YOUR_PAYMENT_REFERENCE")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(CreateCheckoutSessionRequest.RecurringProcessingModelEnum.CARDONFILE)
  .shopperInteraction(CreateCheckoutSessionRequest.ShopperInteractionEnum.CONTAUTH)
  .returnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..")
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Send the request
PaymentsApi service = new PaymentsApi(client);
CreateCheckoutSessionResponse response = service.sessions(createCheckoutSessionRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CreateCheckoutSessionRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the LIVE environment, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(2000);

$createCheckoutSessionRequest = new CreateCheckoutSessionRequest();
$createCheckoutSessionRequest
  ->setReference("YOUR_PAYMENT_REFERENCE")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("CardOnFile")
  ->setShopperInteraction("ContAuth")
  ->setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID");

$requestOptions['idempotencyKey'] = 'UUID';

// Send the request
$service = new PaymentsApi($client);
$response = $service->sessions($createCheckoutSessionRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v32.1.1
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 2000
};

CreateCheckoutSessionRequest createCheckoutSessionRequest = new CreateCheckoutSessionRequest
{
  Reference = "YOUR_PAYMENT_REFERENCE",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = CreateCheckoutSessionRequest.RecurringProcessingModelEnum.CardOnFile,
  ShopperInteraction = CreateCheckoutSessionRequest.ShopperInteractionEnum.ContAuth,
  ReturnUrl = "https://your-company.example.com/checkout?shopperOrder=12xy..",
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
var service = new PaymentsService(client);
var response = service.Sessions(createCheckoutSessionRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v29.0.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const createCheckoutSessionRequest = {
  amount: {
    value: 2000,
    currency: "USD"
  },
  reference: "YOUR_PAYMENT_REFERENCE",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  shopperInteraction: "ContAuth",
  recurringProcessingModel: "CardOnFile"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.sessions(createCheckoutSessionRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "USD",
  Value: 2000,
}

createCheckoutSessionRequest := checkout.CreateCheckoutSessionRequest{
  Reference: "YOUR_PAYMENT_REFERENCE",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("CardOnFile"),
  ShopperInteraction: common.PtrString("ContAuth"),
  ReturnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.SessionsInput().IdempotencyKey("UUID").CreateCheckoutSessionRequest(createCheckoutSessionRequest)
res, httpRes, err := service.PaymentsApi.Sessions(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v13.6.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 2000,
    "currency": "USD"
  },
  "reference": "YOUR_PAYMENT_REFERENCE",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy..",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "CardOnFile"
}

# Send the request
result = adyen.checkout.payments_api.sessions(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 2000,
    :currency => 'USD'
  },
  :reference => 'YOUR_PAYMENT_REFERENCE',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :returnUrl => 'https://your-company.example.com/checkout?shopperOrder=12xy..',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'CardOnFile'
}

# Send the request
result = adyen.checkout.payments_api.sessions(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.0.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "USD",
  value: 2000
};

const createCheckoutSessionRequest: Types.checkout.CreateCheckoutSessionRequest = {
  reference: "YOUR_PAYMENT_REFERENCE",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.CreateCheckoutSessionRequest.RecurringProcessingModelEnum.CardOnFile,
  shopperInteraction: Types.checkout.CreateCheckoutSessionRequest.ShopperInteractionEnum.ContAuth,
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.sessions(createCheckoutSessionRequest, { idempotencyKey: "UUID" });
```

### Tab: Advanced flow

### Store card details

When creating a token for cards:

* [In your Components configuration](#configuration), make sure that `showStorePaymentField` is set to **true**. This shows a switch for your shopper to choose to store their card details.

* Make an API request to [create a token](/online-payments/tokenization/create-tokens) using standard tokenization parameters. You do not need to include any additional parameters for cards.

  **Create a token for one-click payments**

  #### curl

  ```bash
  curl https://checkout-test.adyen.com/v72/payments \
  -H 'x-api-key: ADYEN_API_KEY' \
  -H 'content-type: application/json' \
  -d '{
     "amount":{
        "value":0,
        "currency":"USD"
     },
     "paymentMethod":{
        "type":"scheme",
        "encryptedCardNumber": "test_4111111111111111",
        "encryptedExpiryMonth": "test_03",
        "encryptedExpiryYear": "test_2030",
        "encryptedSecurityCode": "test_737",
        "holderName":"John Smith"
     },
     "reference":"YOUR_ORDER_REFERENCE",
     "shopperInteraction": "Ecommerce",
     "recurringProcessingModel": "CardOnFile",
     "storePaymentMethod": "true",
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "shopperReference":"YOUR_SHOPPER_REFERENCE",
     "returnUrl":"https://your-company.example.com/..."
  }'
  ```

  #### Java

  ```java
  // Adyen Java API Library v39.3.0
  import com.adyen.Client;
  import com.adyen.enums.Environment;
  import com.adyen.model.checkout.*;
  import java.time.OffsetDateTime;
  import java.util.*;
  import com.adyen.model.RequestOptions;
  import com.adyen.service.checkout.*;

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  Client client = new Client("ADYEN_API_KEY", Environment.TEST);

  // Create the request object(s)
  Amount amount = new Amount()
    .currency("USD")
    .value(0L);

  CardDetails cardDetails = new CardDetails()
    .encryptedCardNumber("test_4111111111111111")
    .holderName("John Smith")
    .encryptedSecurityCode("test_737")
    .encryptedExpiryYear("test_2030")
    .encryptedExpiryMonth("test_03")
    .type(CardDetails.TypeEnum.SCHEME);

  PaymentRequest paymentRequest = new PaymentRequest()
    .reference("YOUR_ORDER_REFERENCE")
    .amount(amount)
    .storePaymentMethod(true)
    .merchantAccount("YOUR_MERCHANT_ACCOUNT")
    .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.CARDONFILE)
    .paymentMethod(new CheckoutPaymentMethod(cardDetails))
    .shopperInteraction(PaymentRequest.ShopperInteractionEnum.ECOMMERCE)
    .returnUrl("https://your-company.example.com/...")
    .shopperReference("YOUR_SHOPPER_REFERENCE");

  // Send the request
  PaymentsApi service = new PaymentsApi(client);
  PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
  ```

  #### PHP

  ```php
  <?php
  // Adyen PHP API Library v28.2.0
  use Adyen\Client;
  use Adyen\Environment;
  use Adyen\Model\Checkout\Amount;
  use Adyen\Model\Checkout\CheckoutPaymentMethod;
  use Adyen\Model\Checkout\PaymentRequest;
  use Adyen\Service\Checkout\PaymentsApi;

  $client = new Client();
  $client->setXApiKey("ADYEN_API_KEY");
  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  $client->setEnvironment(Environment::TEST);


  // Create the request object(s)
  $amount = new Amount();
  $amount
    ->setCurrency("USD")
    ->setValue(0);

  $checkoutPaymentMethod = new CheckoutPaymentMethod();
  $checkoutPaymentMethod
    ->setEncryptedCardNumber("test_4111111111111111")
    ->setHolderName("John Smith")
    ->setEncryptedSecurityCode("test_737")
    ->setEncryptedExpiryYear("test_2030")
    ->setEncryptedExpiryMonth("test_03")
    ->setType("scheme");

  $paymentRequest = new PaymentRequest();
  $paymentRequest
    ->setReference("YOUR_ORDER_REFERENCE")
    ->setAmount($amount)
    ->setStorePaymentMethod(true)
    ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
    ->setRecurringProcessingModel("CardOnFile")
    ->setPaymentMethod($checkoutPaymentMethod)
    ->setShopperInteraction("Ecommerce")
    ->setReturnUrl("https://your-company.example.com/...")
    ->setShopperReference("YOUR_SHOPPER_REFERENCE");

  $requestOptions['idempotencyKey'] = 'UUID';

  // Send the request
  $service = new PaymentsApi($client);
  $response = $service->payments($paymentRequest, $requestOptions);
  ```

  #### C\#

  ```cs
  // Adyen .net API Library v32.1.1
  using Adyen;
  using Environment = Adyen.Model.Environment;
  using Adyen.Model;
  using Adyen.Model.Checkout;
  using Adyen.Service.Checkout;

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  var config = new Config()
  {
      XApiKey = "ADYEN_API_KEY",
      Environment = Environment.Test
  };
  var client = new Client(config);

  // Create the request object(s)
  Amount amount = new Amount
  {
    Currency = "USD",
    Value = 0
  };

  CardDetails cardDetails = new CardDetails
  {
    EncryptedCardNumber = "test_4111111111111111",
    HolderName = "John Smith",
    EncryptedSecurityCode = "test_737",
    EncryptedExpiryYear = "test_2030",
    EncryptedExpiryMonth = "test_03",
    Type = CardDetails.TypeEnum.Scheme
  };

  PaymentRequest paymentRequest = new PaymentRequest
  {
    Reference = "YOUR_ORDER_REFERENCE",
    Amount = amount,
    StorePaymentMethod = true,
    MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
    RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.CardOnFile,
    PaymentMethod = new CheckoutPaymentMethod(cardDetails),
    ShopperInteraction = PaymentRequest.ShopperInteractionEnum.Ecommerce,
    ReturnUrl = "https://your-company.example.com/...",
    ShopperReference = "YOUR_SHOPPER_REFERENCE"
  };

  // Send the request
  var service = new PaymentsService(client);
  var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
  ```

  #### NodeJS (JavaScript)

  ```js
  // Adyen Node API Library v29.0.0
  const { Client, CheckoutAPI } = require('@adyen/api-library');

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  const config = new Config({
    apiKey: "ADYEN_API_KEY",
    environment: EnvironmentEnum.TEST
  });

  const client = new Client(config);

  // Create the request object(s)
  const paymentRequest = {
    amount: {
      value: 0,
      currency: "USD"
    },
    paymentMethod: {
      type: "scheme",
      encryptedCardNumber: "test_4111111111111111",
      encryptedExpiryMonth: "test_03",
      encryptedExpiryYear: "test_2030",
      encryptedSecurityCode: "test_737",
      holderName: "John Smith"
    },
    reference: "YOUR_ORDER_REFERENCE",
    shopperInteraction: "Ecommerce",
    recurringProcessingModel: "CardOnFile",
    storePaymentMethod: "true",
    merchantAccount: "YOUR_MERCHANT_ACCOUNT",
    shopperReference: "YOUR_SHOPPER_REFERENCE",
    returnUrl: "https://your-company.example.com/..."
  }

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
  ```

  #### Go

  ```go
  // Adyen Go API Library v21.0.0
  import (
    "context"
    "github.com/adyen/adyen-go-api-library/v21/src/common"
    "github.com/adyen/adyen-go-api-library/v21/src/adyen"
    "github.com/adyen/adyen-go-api-library/v21/src/checkout"
  )
  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  client := adyen.NewClient(&common.Config{
    ApiKey:      "ADYEN_API_KEY",
    Environment: common.TestEnv,
  })

  // Create the request object(s)
  amount := checkout.Amount{
    Currency: "USD",
    Value: 0,
  }

  cardDetails := checkout.CardDetails{
    EncryptedCardNumber: common.PtrString("test_4111111111111111"),
    HolderName: common.PtrString("John Smith"),
    EncryptedSecurityCode: common.PtrString("test_737"),
    EncryptedExpiryYear: common.PtrString("test_2030"),
    EncryptedExpiryMonth: common.PtrString("test_03"),
    Type: common.PtrString("scheme"),
  }

  paymentRequest := checkout.PaymentRequest{
    Reference: "YOUR_ORDER_REFERENCE",
    Amount: amount,
    StorePaymentMethod: common.PtrBool(true),
    MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
    RecurringProcessingModel: common.PtrString("CardOnFile"),
    PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
    ShopperInteraction: common.PtrString("Ecommerce"),
    ReturnUrl: "https://your-company.example.com/...",
    ShopperReference: common.PtrString("YOUR_SHOPPER_REFERENCE"),
  }

  // Send the request
  service := client.Checkout()
  req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
  res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
  ```

  #### Python

  ```py
  # Adyen Python API Library v13.6.0
  import Adyen

  adyen = Adyen.Adyen()
  adyen.client.xapikey = "ADYEN_API_KEY"
  # For the LIVE environment, also include your liveEndpointUrlPrefix.
  adyen.client.platform = "test" # The environment to use library in.

  # Create the request object(s)
  json_request = {
    "amount": {
      "value": 0,
      "currency": "USD"
    },
    "paymentMethod": {
      "type": "scheme",
      "encryptedCardNumber": "test_4111111111111111",
      "encryptedExpiryMonth": "test_03",
      "encryptedExpiryYear": "test_2030",
      "encryptedSecurityCode": "test_737",
      "holderName": "John Smith"
    },
    "reference": "YOUR_ORDER_REFERENCE",
    "shopperInteraction": "Ecommerce",
    "recurringProcessingModel": "CardOnFile",
    "storePaymentMethod": "True",
    "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
    "shopperReference": "YOUR_SHOPPER_REFERENCE",
    "returnUrl": "https://your-company.example.com/..."
  }

  # Send the request
  result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
  ```

  #### Ruby

  ```rb
  # Adyen Ruby API Library v10.4.0
  require "adyen-ruby-api-library"

  adyen = Adyen::Client.new
  adyen.api_key = 'ADYEN_API_KEY'
  # For the LIVE environment, also include your liveEndpointUrlPrefix.
  adyen.env = :test # Set to "live" for live environment

  # Create the request object(s)
  request_body = {
    :amount => {
      :value => 0,
      :currency => 'USD'
    },
    :paymentMethod => {
      :type => 'scheme',
      :encryptedCardNumber => 'test_4111111111111111',
      :encryptedExpiryMonth => 'test_03',
      :encryptedExpiryYear => 'test_2030',
      :encryptedSecurityCode => 'test_737',
      :holderName => 'John Smith'
    },
    :reference => 'YOUR_ORDER_REFERENCE',
    :shopperInteraction => 'Ecommerce',
    :recurringProcessingModel => 'CardOnFile',
    :storePaymentMethod => 'true',
    :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
    :shopperReference => 'YOUR_SHOPPER_REFERENCE',
    :returnUrl => 'https://your-company.example.com/...'
  }

  # Send the request
  result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
  ```

  #### NodeJS (TypeScript)

  ```ts
  // Adyen Node API Library v29.0.0
  import { Client, CheckoutAPI, Types } from "@adyen/api-library";

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  const config = new Config({
    apiKey: "ADYEN_API_KEY",
    environment: EnvironmentEnum.TEST
  });

  const client = new Client(config);

  // Create the request object(s)
  const amount: Types.checkout.Amount = {
    currency: "USD",
    value: 0
  };

  const cardDetails: Types.checkout.CardDetails = {
    encryptedCardNumber: "test_4111111111111111",
    holderName: "John Smith",
    encryptedSecurityCode: "test_737",
    encryptedExpiryYear: "test_2030",
    encryptedExpiryMonth: "test_03",
    type: Types.checkout.CardDetails.TypeEnum.Scheme
  };

  const paymentRequest: Types.checkout.PaymentRequest = {
    reference: "YOUR_ORDER_REFERENCE",
    amount: amount,
    storePaymentMethod: true,
    merchantAccount: "YOUR_MERCHANT_ACCOUNT",
    recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.CardOnFile,
    paymentMethod: cardDetails,
    shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.Ecommerce,
    returnUrl: "https://your-company.example.com/...",
    shopperReference: "YOUR_SHOPPER_REFERENCE"
  };

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
  ```

### Show stored cards

To show stored payment methods in your payment form:

1. In your [/paymentMethods](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods) request, include the [shopperReference](https://docs.adyen.com/api-explorer/Checkout/latest/post/paymentMethods#request-shopperReference) that you specified when creating the token to receive the stored payment details for the shopper.
2. Pass the API response to your client-side app.
3. When [you launch and show the Component](/online-payments/build-your-integration/advanced-flow?platform=Flutter\&integration=Components#show), use the stored payment methods.

The Component shows the stored payment method in the payment form.

### Make a one-click payment

[Make a one-click payment](/online-payments/tokenization/make-token-payments#make-a-one-click-payment) using standard tokenization parameters. You do not need to include any additional parameters for cards.

**Make a one-click payment with a card token**

#### curl

```bash
curl https://checkout-test.adyen.com/v72/payments \
-H 'x-API-key: ADYEN_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
     "amount":{
       "value":2000,
       "currency":"USD"
     },
     "paymentMethod":{
       "type":"scheme",
       "storedPaymentMethodId":"8415718415172204",
       "encryptedSecurityCode":"adyenjs_0_1_18$MT6ppy0FAMVMLH..."
     },
     "reference":"YOUR_ORDER_NUMBER",
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "returnUrl":"https://your-company.example.com/checkout?shopperOrder=12xy..",
     "shopperReference":"YOUR_UNIQUE_SHOPPER_ID",
     "shopperInteraction":"ContAuth",
     "recurringProcessingModel":"CardOnFile"
 }'
```

#### Java

```java
// Adyen Java API Library v39.4.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.checkout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.model.RequestOptions;
import com.adyen.service.checkout.*;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(2000L);

CardDetails cardDetails = new CardDetails()
  .encryptedSecurityCode("adyenjs_0_1_18$MT6ppy0FAMVMLH...")
  .storedPaymentMethodId("8415718415172204")
  .type(CardDetails.TypeEnum.SCHEME);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.CARDONFILE)
  .paymentMethod(new CheckoutPaymentMethod(cardDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.CONTAUTH)
  .returnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..")
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Send the request
PaymentsApi service = new PaymentsApi(client);
PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CheckoutPaymentMethod;
use Adyen\Model\Checkout\PaymentRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the LIVE environment, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(2000);

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setEncryptedSecurityCode("adyenjs_0_1_18\$MT6ppy0FAMVMLH...")
  ->setStoredPaymentMethodId("8415718415172204")
  ->setType("scheme");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("CardOnFile")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("ContAuth")
  ->setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID");

$requestOptions['idempotencyKey'] = 'UUID';

// Send the request
$service = new PaymentsApi($client);
$response = $service->payments($paymentRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v32.1.2
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 2000
};

CardDetails cardDetails = new CardDetails
{
  EncryptedSecurityCode = "adyenjs_0_1_18$MT6ppy0FAMVMLH...",
  StoredPaymentMethodId = "8415718415172204",
  Type = CardDetails.TypeEnum.Scheme
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.CardOnFile,
  PaymentMethod = new CheckoutPaymentMethod(cardDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
  ReturnUrl = "https://your-company.example.com/checkout?shopperOrder=12xy..",
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
var service = new PaymentsService(client);
var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v29.1.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const paymentRequest = {
  amount: {
    value: 2000,
    currency: "USD"
  },
  paymentMethod: {
    type: "scheme",
    storedPaymentMethodId: "8415718415172204",
    encryptedSecurityCode: "adyenjs_0_1_18$MT6ppy0FAMVMLH..."
  },
  reference: "YOUR_ORDER_NUMBER",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  shopperInteraction: "ContAuth",
  recurringProcessingModel: "CardOnFile"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "USD",
  Value: 2000,
}

cardDetails := checkout.CardDetails{
  EncryptedSecurityCode: common.PtrString("adyenjs_0_1_18$MT6ppy0FAMVMLH..."),
  StoredPaymentMethodId: common.PtrString("8415718415172204"),
  Type: common.PtrString("scheme"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("CardOnFile"),
  PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
  ShopperInteraction: common.PtrString("ContAuth"),
  ReturnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v13.6.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 2000,
    "currency": "USD"
  },
  "paymentMethod": {
    "type": "scheme",
    "storedPaymentMethodId": "8415718415172204",
    "encryptedSecurityCode": "adyenjs_0_1_18$MT6ppy0FAMVMLH..."
  },
  "reference": "YOUR_ORDER_NUMBER",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy..",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "CardOnFile"
}

# Send the request
result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 2000,
    :currency => 'USD'
  },
  :paymentMethod => {
    :type => 'scheme',
    :storedPaymentMethodId => '8415718415172204',
    :encryptedSecurityCode => 'adyenjs_0_1_18$MT6ppy0FAMVMLH...'
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :returnUrl => 'https://your-company.example.com/checkout?shopperOrder=12xy..',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'CardOnFile'
}

# Send the request
result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.1.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "USD",
  value: 2000
};

const cardDetails: Types.checkout.CardDetails = {
  encryptedSecurityCode: "adyenjs_0_1_18$MT6ppy0FAMVMLH...",
  storedPaymentMethodId: "8415718415172204",
  type: Types.checkout.CardDetails.TypeEnum.Scheme
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.CardOnFile,
  paymentMethod: cardDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

### Make a subscription payment

[Make a subscription payment](/online-payments/tokenization/make-token-payments#make-a-subscription-or-unscheduled-card-on-file-payment) using standard tokenization parameters. You do not need to include any additional parameters for cards.

**Make a subscription payment with a card token**

#### curl

```bash
curl https://checkout-test.adyen.com/v72/payments \
-H 'x-API-key: ADYEN_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
     "amount":{
       "value":2000,
       "currency":"USD"
     },
     "paymentMethod":{
       "type":"scheme",
       "storedPaymentMethodId":"8415718415172204"
     },
     "reference":"YOUR_ORDER_NUMBER",
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "returnUrl":"...",
     "shopperReference":"YOUR_UNIQUE_SHOPPER_ID",
     "shopperInteraction":"ContAuth",
     "recurringProcessingModel":"Subscription"
 }'
```

#### Java

```java
// Adyen Java API Library v39.4.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.checkout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.model.RequestOptions;
import com.adyen.service.checkout.*;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(2000L);

CardDetails cardDetails = new CardDetails()
  .storedPaymentMethodId("8415718415172204")
  .type(CardDetails.TypeEnum.SCHEME);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.SUBSCRIPTION)
  .paymentMethod(new CheckoutPaymentMethod(cardDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.CONTAUTH)
  .returnUrl("...")
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Send the request
PaymentsApi service = new PaymentsApi(client);
PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CheckoutPaymentMethod;
use Adyen\Model\Checkout\PaymentRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the LIVE environment, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(2000);

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setStoredPaymentMethodId("8415718415172204")
  ->setType("scheme");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("Subscription")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("ContAuth")
  ->setReturnUrl("...")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID");

$requestOptions['idempotencyKey'] = 'UUID';

// Send the request
$service = new PaymentsApi($client);
$response = $service->payments($paymentRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v32.1.2
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 2000
};

CardDetails cardDetails = new CardDetails
{
  StoredPaymentMethodId = "8415718415172204",
  Type = CardDetails.TypeEnum.Scheme
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.Subscription,
  PaymentMethod = new CheckoutPaymentMethod(cardDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
  ReturnUrl = "...",
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
var service = new PaymentsService(client);
var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v29.1.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const paymentRequest = {
  amount: {
    value: 2000,
    currency: "USD"
  },
  paymentMethod: {
    type: "scheme",
    storedPaymentMethodId: "8415718415172204"
  },
  reference: "YOUR_ORDER_NUMBER",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  returnUrl: "...",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  shopperInteraction: "ContAuth",
  recurringProcessingModel: "Subscription"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "USD",
  Value: 2000,
}

cardDetails := checkout.CardDetails{
  StoredPaymentMethodId: common.PtrString("8415718415172204"),
  Type: common.PtrString("scheme"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("Subscription"),
  PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
  ShopperInteraction: common.PtrString("ContAuth"),
  ReturnUrl: "...",
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v13.6.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 2000,
    "currency": "USD"
  },
  "paymentMethod": {
    "type": "scheme",
    "storedPaymentMethodId": "8415718415172204"
  },
  "reference": "YOUR_ORDER_NUMBER",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "returnUrl": "...",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "Subscription"
}

# Send the request
result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 2000,
    :currency => 'USD'
  },
  :paymentMethod => {
    :type => 'scheme',
    :storedPaymentMethodId => '8415718415172204'
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :returnUrl => '...',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'Subscription'
}

# Send the request
result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.1.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "USD",
  value: 2000
};

const cardDetails: Types.checkout.CardDetails = {
  storedPaymentMethodId: "8415718415172204",
  type: Types.checkout.CardDetails.TypeEnum.Scheme
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.Subscription,
  paymentMethod: cardDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  returnUrl: "...",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

### Make an unscheduled card-on-file payment

[Make an unscheduled card-on-file payment](/online-payments/tokenization/make-token-payments#make-a-subscription-or-unscheduled-card-on-file-payment) using standard tokenization parameters. You do not need to include any additional parameters for cards.

**Make an unscheduled card-on-file payment with a card token**

#### curl

```bash
curl https://checkout-test.adyen.com/v72/payments \
-H 'x-API-key: ADYEN_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
     "amount":{
       "value":2000,
       "currency":"USD"
     },
     "paymentMethod":{
       "type":"scheme",
       "storedPaymentMethodId":"8415718415172204"
     },
     "reference":"YOUR_ORDER_NUMBER",
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "returnUrl":"...",
     "shopperReference":"YOUR_UNIQUE_SHOPPER_ID",
     "shopperInteraction":"ContAuth",
     "recurringProcessingModel":"UnscheduledCardOnFile"
 }'
```

#### Java

```java
// Adyen Java API Library v39.4.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.checkout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.model.RequestOptions;
import com.adyen.service.checkout.*;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(2000L);

CardDetails cardDetails = new CardDetails()
  .storedPaymentMethodId("8415718415172204")
  .type(CardDetails.TypeEnum.SCHEME);

PaymentRequest paymentRequest = new PaymentRequest()
  .reference("YOUR_ORDER_NUMBER")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.UNSCHEDULEDCARDONFILE)
  .paymentMethod(new CheckoutPaymentMethod(cardDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.CONTAUTH)
  .returnUrl("...")
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Send the request
PaymentsApi service = new PaymentsApi(client);
PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
<?php
// Adyen PHP API Library v28.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CheckoutPaymentMethod;
use Adyen\Model\Checkout\PaymentRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the LIVE environment, also include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(2000);

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setStoredPaymentMethodId("8415718415172204")
  ->setType("scheme");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setReference("YOUR_ORDER_NUMBER")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("UnscheduledCardOnFile")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("ContAuth")
  ->setReturnUrl("...")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID");

$requestOptions['idempotencyKey'] = 'UUID';

// Send the request
$service = new PaymentsApi($client);
$response = $service->payments($paymentRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v32.1.2
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the LIVE environment, also include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 2000
};

CardDetails cardDetails = new CardDetails
{
  StoredPaymentMethodId = "8415718415172204",
  Type = CardDetails.TypeEnum.Scheme
};

PaymentRequest paymentRequest = new PaymentRequest
{
  Reference = "YOUR_ORDER_NUMBER",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.UnscheduledCardOnFile,
  PaymentMethod = new CheckoutPaymentMethod(cardDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.ContAuth,
  ReturnUrl = "...",
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
var service = new PaymentsService(client);
var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v29.1.0
const { Client, CheckoutAPI } = require('@adyen/api-library');

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const paymentRequest = {
  amount: {
    value: 2000,
    currency: "USD"
  },
  paymentMethod: {
    type: "scheme",
    storedPaymentMethodId: "8415718415172204"
  },
  reference: "YOUR_ORDER_NUMBER",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  returnUrl: "...",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  shopperInteraction: "ContAuth",
  recurringProcessingModel: "UnscheduledCardOnFile"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v21.0.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v21/src/common"
  "github.com/adyen/adyen-go-api-library/v21/src/adyen"
  "github.com/adyen/adyen-go-api-library/v21/src/checkout"
)
// For the LIVE environment, also include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "USD",
  Value: 2000,
}

cardDetails := checkout.CardDetails{
  StoredPaymentMethodId: common.PtrString("8415718415172204"),
  Type: common.PtrString("scheme"),
}

paymentRequest := checkout.PaymentRequest{
  Reference: "YOUR_ORDER_NUMBER",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("UnscheduledCardOnFile"),
  PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
  ShopperInteraction: common.PtrString("ContAuth"),
  ReturnUrl: "...",
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v13.6.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 2000,
    "currency": "USD"
  },
  "paymentMethod": {
    "type": "scheme",
    "storedPaymentMethodId": "8415718415172204"
  },
  "reference": "YOUR_ORDER_NUMBER",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "returnUrl": "...",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "shopperInteraction": "ContAuth",
  "recurringProcessingModel": "UnscheduledCardOnFile"
}

# Send the request
result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
```

#### Ruby

```rb
# Adyen Ruby API Library v10.4.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the LIVE environment, also include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 2000,
    :currency => 'USD'
  },
  :paymentMethod => {
    :type => 'scheme',
    :storedPaymentMethodId => '8415718415172204'
  },
  :reference => 'YOUR_ORDER_NUMBER',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :returnUrl => '...',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :shopperInteraction => 'ContAuth',
  :recurringProcessingModel => 'UnscheduledCardOnFile'
}

# Send the request
result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v29.1.0
import { Client, CheckoutAPI, Types } from "@adyen/api-library";

// For the LIVE environment, also include your liveEndpointUrlPrefix.
const config = new Config({
  apiKey: "ADYEN_API_KEY",
  environment: EnvironmentEnum.TEST
});

const client = new Client(config);

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "USD",
  value: 2000
};

const cardDetails: Types.checkout.CardDetails = {
  storedPaymentMethodId: "8415718415172204",
  type: Types.checkout.CardDetails.TypeEnum.Scheme
};

const paymentRequest: Types.checkout.PaymentRequest = {
  reference: "YOUR_ORDER_NUMBER",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.UnscheduledCardOnFile,
  paymentMethod: cardDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.ContAuth,
  returnUrl: "...",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

## Test and go live

If your client-side integration isn't ready, you can [test API requests with encrypted card details](/development-resources/test-cards-and-credentials/test-card-numbers#test-encrypted-card-details) by adding a `test_` prefix to the test card details.

Before making live card payments:

1. Test your integration using our [test card numbers](/development-resources/test-cards-and-credentials/test-card-numbers). You can check the status of test payments in your [Customer Area](https://ca-test.adyen.com/) > **Transactions** > **Payments**.

2. [Add the cards that you want to accept](/payment-methods/add-payment-methods) in your [live Customer Area](https://ca-live.adyen.com/).

3. Before you can start accepting card payments in the live environment, you need to [assess your PCI DSS compliance](/development-resources/pci-dss-compliance-guide#online-payments) and submit the required *Self-Assessment Questionnaire A* document.

## See also

* [Components integration guide](/online-payments/build-your-integration/sessions-flow?platform=Flutter\&integration=Components)
* [Tokenization](/online-payments/tokenization)
* [Webhooks](/development-resources/webhooks)
* [API Explorer](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/overview)