> This is Payabli documentation. For a complete page index, fetch https://docs.payabli.com/llms.txt — append .md to any page URL for lightweight markdown. For section-level indexes, query parameters, and other AI-optimized access methods, see https://docs.payabli.com/ai-agents.md

# Validate bank account change

POST https://api-sandbox.payabli.com/api/v2/cases/bank-account/{paypointId}/validate
Content-Type: application/json

Validates a bank account change for a paypoint without creating a case.
Runs the same checks the create endpoint runs, and returns blocking
conditions and warnings. Blocking conditions prevent creation; warnings
don't.

Available to both Platform and Enterprise Partners.


Reference: https://docs.payabli.com/developers/api-reference/bankChanges/validate-bank-account-change

## Authentication

- `Authorization` header (bearer token, required)

## Servers

- `https://api-sandbox.payabli.com/api` (Sandbox, default)
- `https://api.payabli.com/api` (Production)

## Request

### Path parameters

- `paypointId` (long, required) — The paypoint's numeric identifier.

### Body (application/json)

- `routingNumber` (string, required) — The 9-digit bank routing number.
- `accountNumber` (string, required) — The bank account number (4 to 17 digits).
- `accountType` (string, required) — The account type. Must be `checking` or `savings`.
- `bankAccountHolderType` (string, required) — The account holder type. Must be `personal` or `business`.
- `bankAccountFunction` (enum, required) — What the bank account is used for. `None` isn't accepted on a request.
  - Allowed values: `Deposits`, `Withdrawals`, `DepositsAndWithdrawals`, `Remittances`, `RemittancesAndDeposits`, `RemittancesAndWithdrawals`, `RemittancesDepositsAndWithdrawals`
- `services` (object, required) — The Pay In and Pay Out services the bank account applies to. Include at least one entry across the two lists.
  - `moneyIn` (list of enum, optional) — Pay In services the account is used for.
    - Allowed values: `Ach`, `Card`, `Cloud`, `Device`, `Wallet`, `Cash`, `Check`
  - `moneyOut` (list of enum, optional) — Pay Out services the account is used for.
    - Allowed values: `Ach`, `VCard`, `Managed`, `Check`, `Rtp`, `Wire`, `Ghost`

## Response

### 200

Validation result

- `isValid` (boolean, required) — Whether the request can be created. False when there are blocking conditions.
- `blockingConditions` (list of string, required) — Conditions that prevent creation. Must be resolved first.
- `warnings` (list of string, required) — Informational warnings. Creation can still proceed.
- `validationErrors` (list of string, required) — Field-level validation errors.

## Examples

**Request**

```json
{
  "routingNumber": "123456789",
  "accountNumber": "987654321",
  "accountType": "checking",
  "bankAccountHolderType": "business",
  "bankAccountFunction": "Deposits",
  "services": {
    "moneyIn": [
      "Ach"
    ],
    "moneyOut": [
      "Ach"
    ]
  }
}
```

**Response**

```json
{
  "isValid": true,
  "blockingConditions": [],
  "warnings": [
    "This paypoint has active batches. Consider scheduling the bank account change after the current batch is closed."
  ],
  "validationErrors": []
}
```

**SDK Code**

```typescript
import { PayabliClient } from "@payabli/sdk-node";

async function main() {
    const client = new PayabliClient({
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET",
    });
    await client.caseManagement.validateBankAccountChange(3040, {
        routingNumber: "123456789",
        accountNumber: "987654321",
        accountType: "checking",
        bankAccountHolderType: "business",
        bankAccountFunction: "Deposits",
        services: {
            moneyIn: [
                "Ach",
            ],
            moneyOut: [
                "Ach",
            ],
        },
    });
}
main();

```

```python
from payabli import payabli, BankAccountServices

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.case_management.validate_bank_account_change(
    paypoint_id=3040,
    routing_number="123456789",
    account_number="987654321",
    account_type="checking",
    bank_account_holder_type="business",
    bank_account_function="Deposits",
    services=BankAccountServices(
        money_in=[
            "Ach"
        ],
        money_out=[
            "Ach"
        ],
    ),
)

```

```java
package com.example.usage;

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.casemanagement.requests.ValidateBankAccountChangeRequest;
import io.github.payabli.api.types.BankAccountServices;
import io.github.payabli.api.types.CaseManagementBankAccountFunction;
import io.github.payabli.api.types.MoneyInService;
import io.github.payabli.api.types.MoneyOutService;
import java.util.Arrays;
import java.util.Optional;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.caseManagement().validateBankAccountChange(
            3040L,
            ValidateBankAccountChangeRequest
                .builder()
                .routingNumber("123456789")
                .accountNumber("987654321")
                .accountType("checking")
                .bankAccountHolderType("business")
                .bankAccountFunction(CaseManagementBankAccountFunction.DEPOSITS)
                .services(
                    BankAccountServices
                        .builder()
                        .moneyIn(
                            Optional.of(
                                Arrays.asList(MoneyInService.ACH)
                            )
                        )
                        .moneyOut(
                            Optional.of(
                                Arrays.asList(MoneyOutService.ACH)
                            )
                        )
                        .build()
                )
                .build()
        );
    }
}
```

```csharp
using PayabliApi;
using System.Threading.Tasks;
using System.Collections.Generic;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.CaseManagement.ValidateBankAccountChangeAsync(
            paypointId: 3040L,
            request: new ValidateBankAccountChangeRequest {
                RoutingNumber = "123456789",
                AccountNumber = "987654321",
                AccountType = "checking",
                BankAccountHolderType = "business",
                BankAccountFunction = CaseManagementBankAccountFunction.Deposits,
                Services = new BankAccountServices {
                    MoneyIn = new List<MoneyInService>(){
                        MoneyInService.Ach,
                    }
                    ,
                    MoneyOut = new List<MoneyOutService>(){
                        MoneyOutService.Ach,
                    }

                }
            }
        );
    }

}

```

```go
package example

import (
    context "context"

    payabli "github.com/payabli/sdk-go"
    client "github.com/payabli/sdk-go/client"
    option "github.com/payabli/sdk-go/option"
)

func do() {
    client := client.NewClient(
        option.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    request := &payabli.ValidateBankAccountChangeRequest{
        RoutingNumber: "123456789",
        AccountNumber: "987654321",
        AccountType: "checking",
        BankAccountHolderType: "business",
        BankAccountFunction: payabli.CaseManagementBankAccountFunctionDeposits,
        Services: &payabli.BankAccountServices{
            MoneyIn: []payabli.MoneyInService{
                payabli.MoneyInServiceAch,
            },
            MoneyOut: []payabli.MoneyOutService{
                payabli.MoneyOutServiceAch,
            },
        },
    }
    client.CaseManagement.ValidateBankAccountChange(
        context.TODO(),
        int64(3040),
        request,
    )
}

```

```php
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\CaseManagement\Requests\ValidateBankAccountChangeRequest;
use Payabli\Types\CaseManagementBankAccountFunction;
use Payabli\Types\BankAccountServices;
use Payabli\Types\MoneyInService;
use Payabli\Types\MoneyOutService;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->caseManagement->validateBankAccountChange(
    3040,
    new ValidateBankAccountChangeRequest([
        'routingNumber' => '123456789',
        'accountNumber' => '987654321',
        'accountType' => 'checking',
        'bankAccountHolderType' => 'business',
        'bankAccountFunction' => CaseManagementBankAccountFunction::Deposits->value,
        'services' => new BankAccountServices([
            'moneyIn' => [
                MoneyInService::Ach->value,
            ],
            'moneyOut' => [
                MoneyOutService::Ach->value,
            ],
        ]),
    ]),
);

```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api-sandbox.payabli.com/api/v2/cases/bank-account/3040/validate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"routingNumber\": \"123456789\",\n  \"accountNumber\": \"987654321\",\n  \"accountType\": \"checking\",\n  \"bankAccountHolderType\": \"business\",\n  \"bankAccountFunction\": \"Deposits\",\n  \"services\": {\n    \"moneyIn\": [\n      \"Ach\"\n    ],\n    \"moneyOut\": [\n      \"Ach\"\n    ]\n  }\n}"

response = http.request(request)
puts response.read_body
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "routingNumber": "123456789",
  "accountNumber": "987654321",
  "accountType": "checking",
  "bankAccountHolderType": "business",
  "bankAccountFunction": "Deposits",
  "services": [
    "moneyIn": ["Ach"],
    "moneyOut": ["Ach"]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/cases/bank-account/3040/validate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```