> 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

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: payabliApi-oas
  version: 1.0.0
paths:
  /v2/cases/bank-account/{paypointId}/validate:
    post:
      operationId: ValidateBankAccountChange
      summary: Validate bank account change
      description: |
        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.
      tags:
        - caseManagement
      parameters:
        - name: paypointId
          in: path
          description: The paypoint's numeric identifier.
          required: true
          schema:
            type: integer
            format: int64
      responses:
        '200':
          description: Validation result
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PreCreationValidationResult'
        '400':
          description: Bad request / invalid data.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PayabliErrorBody'
        '401':
          description: Unauthorized request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PayabliErrorBody'
        '403':
          description: Consent error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PayabliErrorBody'
        '500':
          description: Internal server error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PayabliErrorBody'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ValidateBankAccountChangeRequest'
servers:
  - url: https://api-sandbox.payabli.com/api
    description: Sandbox
  - url: https://api.payabli.com/api
    description: Production
components:
  schemas:
    caseManagement_BankAccountFunction:
      type: string
      enum:
        - Deposits
        - Withdrawals
        - DepositsAndWithdrawals
        - Remittances
        - RemittancesAndDeposits
        - RemittancesAndWithdrawals
        - RemittancesDepositsAndWithdrawals
      description: What the bank account is used for. `None` isn't accepted on a request.
      title: caseManagement_BankAccountFunction
    MoneyInService:
      type: string
      enum:
        - Ach
        - Card
        - Cloud
        - Device
        - Wallet
        - Cash
        - Check
      description: A Pay In service the bank account is used for.
      title: MoneyInService
    MoneyOutService:
      type: string
      enum:
        - Ach
        - VCard
        - Managed
        - Check
        - Rtp
        - Wire
        - Ghost
      description: A Pay Out service the bank account is used for.
      title: MoneyOutService
    BankAccountServices:
      type: object
      properties:
        moneyIn:
          type: array
          items:
            $ref: '#/components/schemas/MoneyInService'
          description: Pay In services the account is used for.
        moneyOut:
          type: array
          items:
            $ref: '#/components/schemas/MoneyOutService'
          description: Pay Out services the account is used for.
      description: >-
        The Pay In and Pay Out services the bank account applies to. Include at
        least one entry across the two lists.
      title: BankAccountServices
    ValidateBankAccountChangeRequest:
      type: object
      properties:
        routingNumber:
          type: string
          description: The 9-digit bank routing number.
        accountNumber:
          type: string
          description: The bank account number (4 to 17 digits).
        accountType:
          type: string
          description: The account type. Must be `checking` or `savings`.
        bankAccountHolderType:
          type: string
          description: The account holder type. Must be `personal` or `business`.
        bankAccountFunction:
          $ref: '#/components/schemas/caseManagement_BankAccountFunction'
        services:
          $ref: '#/components/schemas/BankAccountServices'
      required:
        - routingNumber
        - accountNumber
        - accountType
        - bankAccountHolderType
        - bankAccountFunction
        - services
      description: The bank account details to validate before creating a case.
      title: ValidateBankAccountChangeRequest
    PreCreationValidationResult:
      type: object
      properties:
        isValid:
          type: boolean
          description: >-
            Whether the request can be created. False when there are blocking
            conditions.
        blockingConditions:
          type: array
          items:
            type: string
          description: Conditions that prevent creation. Must be resolved first.
        warnings:
          type: array
          items:
            type: string
          description: Informational warnings. Creation can still proceed.
        validationErrors:
          type: array
          items:
            type: string
          description: Field-level validation errors.
      required:
        - isValid
        - blockingConditions
        - warnings
        - validationErrors
      description: The result of validating a bank account change before creating a case.
      title: PreCreationValidationResult
    PayabliErrorBodyResponseData:
      type: object
      properties:
        explanation:
          type: string
          description: Human-readable explanation of what happened.
        todoAction:
          type: string
          description: Suggested resolution.
      description: Object with detailed error context.
      title: PayabliErrorBodyResponseData
    PayabliErrorBody:
      type: object
      properties:
        isSuccess:
          type: boolean
          description: Always `false` for error responses.
        responseCode:
          type: integer
          description: |
            Code for the response. Learn more in
            [API Response Codes](/developers/api-reference/api-responses).
        responseText:
          type: string
          description: Error text describing what went wrong.
        responseData:
          $ref: '#/components/schemas/PayabliErrorBodyResponseData'
          description: Object with detailed error context.
      required:
        - isSuccess
        - responseText
      description: |
        Shape returned by every Payabli API error response. The `responseData`
        object carries human-readable error context.
      title: PayabliErrorBody

```

## 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();
    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.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.PayabliPayabliApiOasClient;
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) {
        PayabliPayabliApiOasClient client = PayabliPayabliApiOasClient
            .builder()
            .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 PayabliPayabliApiOas;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace Usage;

public class Example
{
    public async Task Do() {
        var client = new PayabliPayabliApiOasClient();

        await client.CaseManagement.ValidateBankAccountChangeAsync(
            3040L,
            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"
)

func do() {
    client := client.NewClient()
    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();
$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["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 = ["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()
```