> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gr4vy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Nuvei - Bank

> Configure ACH bank payments via Nuvei as a payment method in Gr4vy.

Nuvei is a global payment provider that offers comprehensive payment processing solutions across multiple payment methods and regions.

The Nuvei bank connector enables you to process ACH bank payments by submitting bank account details directly via the API. See [Direct bank payments](/connections/payments/bank) for an overview of the direct integration flow.

## Setup

Please follow the [common Nuvei instructions](./nuvei) to get set up with Nuvei.

After setting up your Nuvei account, make sure ACH bank payments are enabled as a payment method on your account.

Nuvei requires the following fields to be collected during checkout for bank transactions:

* First name and last name
* Billing country

## Features

Nuvei bank payments support the following features:

* **Direct capture** - Capture funds immediately at the time of the transaction
* **Refunds** - Refund transactions in full or in part
* **Partial refunds** - Refund a portion of the original transaction amount
* **Transaction synchronization** - Keep payment statuses synchronized with Nuvei
* **Idempotency** - Gr4vy generates and sends a `clientRequestId` with every request to Nuvei. To enable idempotency, contact your Nuvei Account Manager to make `clientRequestId` mandatory on your account

## Supported countries

Nuvei supports transactions from buyers in `US`.

## Supported currencies

Nuvei supports processing payments in `USD`.

## Limitations

The following features are not supported by this connector:

* **Delayed capture** - Authorization and capture must happen together
* **Partial capture** - Cannot capture a portion of the authorized amount
* **Void** - Cannot cancel transactions once initiated
* **Payment method tokenization** - Cannot store payment methods for recurring transactions
* **Zero auth** - Zero-dollar verification transactions are not supported
* **Settlement reporting** - Settlement reporting is not available

## Integration

To process a bank payment via Nuvei, submit bank account details directly with `payment_method.method` set to `bank` and `payment_method.scheme` set to `ach`.

<CodeGroup>
  ```csharp C# theme={"system"}
  var transaction = await client.Transactions.CreateAsync(
    transactionCreate: new TransactionCreate()
    {
      Amount = 1299,
      Currency = "USD",
      Country = "US",
      Intent = "capture",
      PaymentMethod = TransactionCreatePaymentMethod.CreateACHBankPaymentMethodCreate(
        new ACHBankPaymentMethodCreate()
        {
          AccountNumber = "1234567890",
          RoutingNumber = "011000138",
          AccountType = "checking",
          AccountHolder = new BankAccountHolder()
          {
            FirstName = "John",
            LastName = "Doe"
          }
        }
      ),
      Buyer = new GuestBuyer()
      {
        BillingDetails = new BillingDetails()
        {
          FirstName = "John",
          LastName = "Doe"
        }
      },
      PaymentServiceId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    }
  );
  ```

  ```go Go theme={"system"}
  amount := int64(1299)
  currency := "USD"
  country := "US"
  paymentServiceId := "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

  achPaymentMethod := components.ACHBankPaymentMethodCreate{
    AccountNumber: "1234567890",
    RoutingNumber: "011000138",
    AccountType:   components.AccountTypeChecking,
    AccountHolder: components.BankAccountHolder{
      FirstName: gr4vy.String("John"),
      LastName:  gr4vy.String("Doe"),
    },
  }
  paymentMethod := components.CreateTransactionCreatePaymentMethodACHBankPaymentMethodCreate(achPaymentMethod)

  transactionCreate := components.TransactionCreate{
    Amount:           amount,
    Currency:         currency,
    Country:          &country,
    Intent:           gr4vy.Pointer(components.TransactionIntentCapture),
    PaymentMethod:    &paymentMethod,
    Buyer: &components.GuestBuyer{
      BillingDetails: &components.BillingDetails{
        FirstName:    gr4vy.String("John"),
        LastName:     gr4vy.String("Doe"),
      },
    },
    PaymentServiceID: &paymentServiceId,
  }

  transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
  ```

  ```java Java theme={"system"}
  CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
    .transactionCreate(TransactionCreate.builder()
      .amount(1299L)
      .currency("USD")
      .country("US")
      .intent(TransactionIntent.CAPTURE)
      .paymentMethod(TransactionCreatePaymentMethod.of(ACHBankPaymentMethodCreate.builder()
        .accountNumber("1234567890")
        .routingNumber("011000138")
        .accountType(AccountType.CHECKING)
        .accountHolder(BankAccountHolder.builder()
          .firstName("John")
          .lastName("Doe")
          .build())
        .build()))
      .buyer(GuestBuyer.builder()
        .billingDetails(BillingDetails.builder()
          .firstName("John")
          .lastName("Doe")
          .build())
        .build())
      .build())
    .call();

  Transaction transaction = transactionResponse.transaction().orElse(null);
  ```

  ```php PHP theme={"system"}
  $transactionCreate = new TransactionCreate(
    amount: 1299,
    currency: 'USD',
    country: 'US',
    intent: 'capture',
    paymentMethod: new ACHBankPaymentMethodCreate(
      accountNumber: '1234567890',
      routingNumber: '011000138',
      accountType: 'checking',
      accountHolder: new BankAccountHolder(
        firstName: 'John',
        lastName: 'Doe'
      )
    ),
    buyer: new GuestBuyer(
      billingDetails: new BillingDetails(
        firstName: 'John',
        lastName: 'Doe'
      )
    ),
    paymentServiceId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  );
  $response = $sdk->transactions->create($transactionCreate);
  $transaction = $response->transaction;
  ```

  ```python Python theme={"system"}
  transaction = client.transactions.create(
    amount=1299,
    currency="USD",
    country="US",
    intent="capture",
    payment_method={
      "method": "bank",
      "scheme": "ach",
      "account_number": "1234567890",
      "routing_number": "011000138",
      "account_type": "checking",
      "account_holder": {
        "first_name": "John",
        "last_name": "Doe"
      }
    },
    buyer={
      "billing_details": {
        "first_name": "John",
        "last_name": "Doe"
      }
    },
    payment_service_id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  )
  ```

  ```ts TypeScript theme={"system"}
  const transaction = await client.transactions.create({
    amount: 1299,
    currency: "USD",
    country: "US",
    intent: "capture",
    paymentMethod: {
      method: "bank",
      scheme: "ach",
      accountNumber: "1234567890",
      routingNumber: "011000138",
      accountType: "checking",
      accountHolder: {
        firstName: "John",
        lastName: "Doe"
      }
    },
    buyer: {
      billingDetails: {
        firstName: "John",
        lastName: "Doe"
      }
    },
    paymentServiceId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  });
  ```
</CodeGroup>

## Testing

Refer to [Nuvei's documentation](https://docs.nuvei.com/) for available test account numbers and ACH test scenarios in the sandbox environment.