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

# Chase Orbital - Bank account (ACH)

> Process ACH payments from bank accounts stored in Gr4vy through Chase Orbital.

**Chase Orbital**

Chase Orbital is a payment gateway from JPMorgan Chase. The bank connector debits a
buyer's bank account directly using the account number and routing number instead of card
details.

Chase calls this product Electronic Check Processing (ECP). It is boarded separately from
card processing, so a Chase Orbital account that already takes cards does not
automatically accept bank payments.

## Setup

Speak to your Chase Orbital account manager to have ECP enabled on the merchant ID you
want to use, and to obtain sandbox credentials.

To sign up for a Chase Orbital test account, visit the
[Developer Center](https://secure.paymentech.com/devcenter/products) page and
select **Get Access**.

Ask your account manager to confirm two more things before you go live.

* **The processing currency of the merchant ID.** Accepting a second currency requires a
  second merchant ID, and therefore a second Chase Orbital bank connection in Gr4vy.
* **Soft descriptor support.** The merchant ID and terminal ID have to be enabled for soft
  descriptors before your merchant name and product description reach the buyer's bank
  statement.

## Connector configuration

Bank payments are routed directly rather than through Flow. When you create a transaction,
set the `payment_service_id` parameter to the ID of your Chase Orbital bank connection.

The connector ID can be found in the dashboard under **Connections** ->
**Configured connections**.

## Credentials

When setting up Chase Orbital in the dashboard, configure the following credentials. They
are the same credentials used by the Chase Orbital card connector, so a merchant ID that
is boarded for both products uses one set of values.

* **Merchant ID** - The merchant ID assigned by Chase Orbital for your account. You can see
  this in the Chase Orbital Development Center **Dashboard** -> **Overview** ->
  **Project** -> **Acquirer ID**.
* **Username** - The Chase Orbital username shared by your account manager.
* **Password** - The Chase Orbital password shared by your account manager.

## Capabilities

This list is for guidance only. It doesn't guarantee availability or
create any rights, and the provider may need to enable some features for
your account.

## Supported countries

**Bank account (ACH)**

## Supported currencies

**Bank account (ACH)**

## Limitations

The following features are not supported by this connector:

* **Delayed capture** - Authorization and capture always happen together
* **Partial capture** - Cannot capture a portion of the authorized amount
* **Void** - Cannot cancel a transaction once it is submitted. Use a refund instead
* **Payment method tokenization** - Bank accounts cannot be stored outside of a
  transaction
* **Transaction sync** - Transaction synchronization is not supported
* **Settlement reporting** - Settlement reporting is available for Chase Orbital card
  payments only

## Integration

The connection requires the following fields in the transaction request.

* `payment_method.account_number` - The buyer's bank account number.
* `payment_method.routing_number` - The buyer's routing number. US routing numbers are 9
  digits. For Canada, use the routing number format provided by Chase Orbital.
* `payment_method.account_type` - Either `checking` or `savings`.
* `payment_method.account_holder` - The account holder's name.
* `buyer.billing_details.first_name` and `buyer.billing_details.last_name` - Required by
  Chase for internet-authorized bank debits.

Sending the rest of `buyer.billing_details.address` is recommended: Gr4vy forwards it to
Chase for address verification and returns the result on the transaction.

The following samples also set `payment_service_id`, as described under
[Connector configuration](#connector-configuration).

```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()
      {
        Method = ACHBankPaymentMethodCreate.MethodEnum.Bank,
        Scheme = ACHBankPaymentMethodCreate.SchemeEnum.Ach,
        AccountNumber = "012345678",
        RoutingNumber = "011000138",
        AccountType = ACHBankPaymentMethodCreate.AccountTypeEnum.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"
firstName := "John"
lastName := "Doe"
paymentServiceId := "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

achPaymentMethod := components.ACHBankPaymentMethodCreate{
  Method:        components.ACHBankPaymentMethodCreateMethodBank,
  Scheme:        components.ACHBankPaymentMethodCreateSchemeAch,
  AccountNumber: "012345678",
  RoutingNumber: "011000138",
  AccountType:   components.ACHBankPaymentMethodCreateAccountTypeChecking,
  AccountHolder: &components.BankAccountHolder{
    FirstName: &firstName,
    LastName:  &lastName,
  },
}
paymentMethod := components.CreateTransactionCreatePaymentMethodACHBankPaymentMethodCreate(achPaymentMethod)

transactionCreate := components.TransactionCreate{
  Amount:        amount,
  Currency:      currency,
  Country:       &country,
  Intent:        components.CreateTransactionIntentCapture,
  PaymentMethod: &paymentMethod,
  Buyer: &components.GuestBuyer{
    BillingDetails: &components.BillingDetails{
      FirstName: &firstName,
      LastName:  &lastName,
    },
  },
  PaymentServiceID: &paymentServiceId,
}

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

```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(1299L)
    .currency("USD")
    .country("US")
    .intent(Intent.CAPTURE)
    .paymentMethod(TransactionCreatePaymentMethod.of(ACHBankPaymentMethodCreate.builder()
      .method(ACHBankPaymentMethodCreate.Method.BANK)
      .scheme(ACHBankPaymentMethodCreate.Scheme.ACH)
      .accountNumber("012345678")
      .routingNumber("011000138")
      .accountType(ACHBankPaymentMethodCreate.AccountType.CHECKING)
      .accountHolder(BankAccountHolder.builder()
        .firstName("John")
        .lastName("Doe")
        .build())
      .build()))
    .buyer(GuestBuyer.builder()
      .billingDetails(BillingDetails.builder()
        .firstName("John")
        .lastName("Doe")
        .build())
      .build())
    .paymentServiceId("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
    .build())
  .call();

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

```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
  amount: 1299,
  currency: 'USD',
  country: 'US',
  intent: Intent::Capture,
  paymentMethod: new ACHBankPaymentMethodCreate(
    method: ACHBankPaymentMethodCreateMethod::Bank,
    scheme: ACHBankPaymentMethodCreateScheme::Ach,
    accountNumber: '012345678',
    routingNumber: '011000138',
    accountType: ACHBankPaymentMethodCreateAccountType::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": "012345678",
    "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: "012345678",
    routingNumber: "011000138",
    accountType: "checking",
    accountHolder: {
      firstName: "John",
      lastName: "Doe"
    }
  },
  buyer: {
    billingDetails: {
      firstName: "John",
      lastName: "Doe"
    }
  },
  paymentServiceId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
});
```

An approved transaction comes back as captured, with no buyer approval step. For the field
reference, vaulting, and recurring payment flows shared by every bank connector, see
[Bank accounts](https://gr4vy.radial-commerce.com/connections/payments/bank.md).

### Statement descriptors

Chase shows two values on the buyer's bank statement: your merchant name, truncated to 15
characters, and the product description, truncated to 10 characters. The merchant name
comes from your Gr4vy merchant profile and the product description from the transaction
description.

When no merchant name is set, Gr4vy sends the transaction description as the merchant
name instead. The product description can be empty on its own without affecting the
merchant name. Only when neither value is available does Gr4vy omit the soft descriptor
altogether, and Chase falls back to the defaults configured on the Transaction Division.

## Testing

Ask your Chase implementation contact for test account details for your sandbox merchant
ID. The sandbox validates routing numbers, so an account with an invalid routing number is
declined with `Invalid Transit Routing Number` rather than approved.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.